Реализация с помощью программы внутренней работы цифровых элементов с использованием объектно-ориентированного подхода

Особенности реализации главных элементов разрабатываемой программы (цифровые элементы) с помощью объектно-ориентированного подхода. Применение принципа инкапсуляции для защиты данных. Конструирование классов, описание и тестирование программного продукта.

Рубрика Программирование, компьютеры и кибернетика
Вид курсовая работа
Язык русский
Дата добавления 10.05.2015
Размер файла 2,3 M

Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже

Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.

Размещено на http://www.allbest.ru/

Содержание

  • Введение
  • 1. Анализ технического задания
  • 2. Конструирование классов
  • 3. Описание программы
  • 4. Тестирование
  • Заключение
  • Список литературы
  • Приложение

Введение

Объектно-ориентированное программирование (ООП) - это технология, подход, основанный на представлении программ в виде совокупности объектов, каждый из которых является реализацией собственного класса.

Термин объект почти одновременно возник в начале 70-х годов в разных независимых друг от друга областях компьютерных наук. Этот термин означал разные, хотя и взаимосвязанные понятия, изобретенные для того, чтобы уменьшить сложность систем программного обеспечения. Объекты использовались для представления компонентов системы, допускающей разложение на модули или фрагменты представляемых знаний. На эволюцию объектно-ориентированных концепций оказали влияние следующие события:

• Усовершенствование архитектуры компьютеров, включая повышение мощности систем и аппаратной поддержки операционных систем;

• Развитие языков программирования, таких как Simula, Smalltalk, CLU и Ada;

• Достижения методологии программирования, включая принципы

модульности и сокрытия данных.

К этому еще следует добавить три момента, оказавшие влияние на становление объектного подхода:

• развитие теории баз данных;

• исследования в области искусственного интеллекта;

• достижения философии и теории познания.

Концепция объекта возникла более 20 лет назад при конструировании компьютеров с дескрипторной (descriptor-based) и мандатной (capability-baseds) архитектурой. Эти разновидности архитектуры отличались от классической архитектуры фон Неймана и пытались преодолеть разрыв между высоким уровнем абстракций, присущих для языков программирования, и низким уровнем абстракций, характерных для компьютеров. По мнению сторонников этих подходов, преимущества новых разновидностей архитектуры позволяли лучше выявлять ошибки, повышали эффективность выполнения программ, сокращали количество инструкций, упрощали компиляцию и снижали объем требуемой памяти. Компьютеры тоже могут иметь объектно-ориентированную архитектуру.

Как полагает Гради Буч, каждый стиль программирования имеет свою концептуальную основу и требует уникального подхода к решению задачи. Основой объектно-ориентированного стиля является объектная модель. Эта модель состоит из следующих четырех главных элементов:

• абстракция;

• инкапсуляция;

• модульность;

• иерархия;

• Абстракция - в объектно-ориентированном программировании это придание объекту характеристик, которые отличают его от всех других объектов, четко определяя его концептуальные границы. Это позволяет работать с объектами, не вдаваясь в особенности их реализации. Абстракция данных - популярная и в общем неверно определяемая техника программирования. Фундаментальная идея состоит в разделении несущественных деталей реализации подпрограммы и характеристик существенных для корректного ее использования.

• Инкапсуляция - свойство языка программирования, позволяющее пользователю не задумываться о сложности реализации используемого программного компонента (что у него внутри?), а взаимодействовать с ним посредством предоставляемого интерфейса (публичных методов и членов), а также объединить и защитить жизненно важные для компонента данные.

• При этом пользователю предоставляется только спецификация (интерфейс) объекта. Пользователь может взаимодействовать с объектом только через этот интерфейс.

• Наследование - один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с инкапсуляцией, полиморфизмом и абстракцией), позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом. Другими словами, класс-наследник реализует спецификацию уже существующего класса (базовый класс). Это позволяет обращаться с объектами класса-наследника точно так же, как с объектами базового класса.

• Для написания более сложных программ, были разработаны принципы объектно-ориентированного программирования, которое позволяет разложить проблему на составные части.

Класс - разновидность абстрактного типа данных в объектно-ориентированном программировании, характеризуемый способом своего построения.

Почти каждому члену класса можно установить модификатор доступа.

Модификаторы бывают:

· Private;

· Protected;

· Public;

Класс является одним из ключевых понятий в ООП. Классы образуют иерархию, построенную на принципах наследования. Класс схож с общей моделью, на основе которой создаются объекты. Например, класс auto может обладать характеристиками, присущими общему представлению об автомобиле. Создание класса - это создание нового типа данных. В процессе создания класса мы "рассказываем" компьютеру о роде и объеме данных, которые может хранить новый тип, а также какие действия могут выполняться для нового типа. Затем можно использовать новый класс для создания переменных нового типа - объектов данного класса. Все поля данных и методы объявляются внутри класса. Объект является конкретным экземпляром класса. Иначе говоря, класс объявляет свойства, которыми обладает объект, а объект хранит конкретные значения этих свойств.

Методы - это функции, которые принадлежат классу и определяют действия, которые можно выполнять для объекта класса. Методы есть обыкновенные функции, являющиеся частью объекта. Они позволяют определить возможности объекта, а их основное назначение - работа с полями класса. Поля или члены-данные класса - это переменные, которые определяют, какого рода данные может хранить объект класса. Компонентами класса являются все методы и поля данных, принадлежащие этому классу.

В данной курсовой работе основной задачей является реализация с помощью программы внутренней работы цифровых элементов с использованием объектно-ориентированного подхода. Основным акцентом при этом является то, что главные элементы разрабатываемой программы - в данному случае все цифровые элементы должны быть реализованы конкретно в виде объектов. В настоящее время объектно-ориентированный подход широко используется при необходимости описания работы каких-либо реальных объектов их свойств и параметров.

В данной курсовой работе будет применен принцип инкапсуляции, который позволяет защитить данные. Для этого используется ключевое слово private. Все поля всех классов защищены, и обращение к ним происходит через методы самого класса.

Также представленная задача требует для своей реализации использовать принцип наследования. Благодаря его существованию, процесс программирования облегчается, происходит экономия ресурсов и повышается быстродействие, что, несомненно, является главным достоинством ООП.

1. Анализ технического задания

Дан комбинационный элемент "ИЛИ" с 3-мя входами и 1-м выходом.

Для наглядности представлена его схема.

Рис. 1. Комбинационный элемент "ИЛИ"

Далее приведена таблица истинности.

1

2

3

ИЛИ

0

0

0

0

0

0

1

1

0

1

0

1

0

1

1

1

1

0

0

1

1

0

1

1

1

1

0

1

1

1

1

1

Рис. 2. Построения комбинационного элемента "ИЛИ".

Если хотя бы один вход будет равен 1, Дизъюнкция будет 1.

Исходя из этого можно сделать вывод, что выход комбинационного элемента будет равен 1, если на входе есть хоть один 1. Если же все входные элементы равны 0, то выход равен 0.

Триггер - класс электронных устройств, обладающих способностью длительно находиться в одном из двух устойчивых состояний и чередовать их под воздействием внешних сигналов. Каждое состояние триггера легко распознаётся по значению выходного напряжения. Отличительной особенностью триггера как функционального устройства является свойство запоминания двоичной информации. Под памятью триггера подразумевают способность оставаться в одном из двух состояний и после прекращения действия переключающего сигнала. Приняв одно из состояний за "1", а другое за "0", можно считать, что триггер хранит один разряд числа, записанного в двоичном коде.

Рис. 3 Схема триггера JK

Регистром называется функциональный узел, осуществляющий приём, хранение и передачу информации. Регистры состоят из группы триггеров. По типу приёма и выдачи информации различают 2 типа регистров:

С последовательным приёмом и выдачей информации - сдвиговые регистры. С параллельным приёмом и выдачей информации - параллельные регистры. В данной работе используется сдвиговый регистр, который представляет собой параллельно соединённую цепочку триггеров.

инкапсуляция цифровой элемент программа

Рис. 4. схема регистра.

2. Конструирование классов

Исходя из задания, нам требуется создать 4 класса, связанных между собой отношениями. Для удобства написания программы, будут даны классам "говорящие" имена.

Соответственно у нас будет класс "ELEMENT”. Это базовый класс и единственная его обязанность - работать с его полем "имя элемента" (name), а точнее изменять его. Это модификатор. Также класс имеет конструктор для создания объектов и деструктор для их уничтожения. Помимо этого, имеются поля хранящие в себе количество входов и выходов элемента.

Поля Класса:

string name; - содержит в себе имя элемента

int AmountInput; - число входов элемента

int AmountOutput; - число выходов элемента

Методы Класса:

string GetName () - возвращает имя объекта

int GetIn () - возвращает количество входов объекта

int GetOut () - возвращает количество выходов объекта

~ELEMENT () - деструктор

ELEMENT () - конструктор по умолчанию

ELEMENT (string S, int K1, int K2) - конструктор с параметрами

void ConfigName (string S) - модификатор имени объекта

void ConfigElement (string S, int K1, int K2) - модификатор объекта

Наследником класса " ELEMENT ” выступает класс "KOMBIN”. Его обязанности: работать с входными значениями - задавать, получать их; работать с выходным значением - генерировать его при помощи вычисления. Класс имеет модификатор, селектор, конструктор, конструктор копирования и деструктор. Класс имеет множество входов и один выход.

Поля Класса:

int * Input; - целочисленный массив указателей на значения на входах элемента.

Методы Класса:

void SetParametres () - ф-я позволяющая задавать значения а входах элемента.

int Output () - возвращает сигнал на выходе объекта

~ KOMBIN () - деструктор

KOMBIN () - конструктор по умолчанию

KOMBIN (string name, int K): ELEMENT (name, K, 1) - конструктор с параметрами

void ConfigName (string S) - модификатор имени объекта

void ConfigElement (string S, int K1, int K2) - модификатор объекта

Еще одним наследником класса " ELEMENT ” является класс "MEMORY”. В его обязанности входит: работать с входными значениями, получать их; определять состояние экземпляра класса в текущий момент времени.

В классе имеются модификатор, селектор, конструктор, конструктор копирования, деструктор.

Имеет входы, соответствующие типу JK триггера, входы установки и сброса и 2 выхода - прямой и инверсный.

Поля Класса:

int С - целочисленная переменная хранит в себе значение предыдущего

синхро-импульса.

int Input [5] - целочисленный массив состоящий из 5 элементов хранящих в себе значения на входах JK триггера.

int Quas - выходной сигнал триггера.

int Revs - инверсный сигнал триггера.

Методы Класса:

int calculations () - функция занимающаяся вычисление выходного сигнала.

void KoyJot () - функция вычисляющая соотношение между K и J.

MEMORY () - конструктор по умолчанию.

MEMORY (MEMORY ob, string name): ELEMENT (name, 5,2) - конструктор копирования.

MEMORY (string name): ELEMENT (name, 5,2) - конструктор с параметрами.

int OutPut () возвращает значение сигнал на выходе объекта.

int ReJ () возвращает значение на входном сигнале J объекта.

int ReK () - возвращает значение на входном сигнале K объекта.

int ReMC () - возвращает значение на прошлого синхро-импульса.

int ReSS () - возвращает значение на входном сигнале синхро-импульса объекта.

int ReS () возвращает значение на входном сигнале S объекта.

int ReR () возвращает значение на входном сигнале R объекта.

int RevsOutPut () - возвращает значение инверсного выхода элемента.

void SetDirectParameters () - задает параметры входных сигналов.

void SetOJKDirectParameters (int a, int b, int ss) - аналогично предыдущему void SetORSDirectParameters (int a, int b) - аналогично предыдущему int SieRa () - функция вычисляющая соотношение между управляющими входами R и S.

Также будет использоваться класс "REGISTER", где класс "MEMORY" используется, как включаемый. Его обязанности: задавать значения на входах экземпляра класса, получать это значение; работать с состоянием экземпляра класса. Соответственно, у него есть модификатор и селектор.

Поля Класса:

int Drop; - вход сброса.

MEMORY obj [8]; - массив триггеров из которых состоит регистр.

int RInput [8] [5]; - значение входных сигналов регистра.

int RC; - предыдущие значение синхро-сигнала.

int Select; - вход установки.

Методы Класса:

REGISTER (string name): ELEMENT (name, 40, 16) - конструктор с параметрами.

void RegisterCalculations () - вычисляет значение на выходах регистра.

void RSetDirectParameters () - задает значение на входах регистра.

int OutInput (int r, int e) - возвращает значение входа по запросу.

Диаграмма классов UML.

3. Описание программы

Подключаемые пространства имен:

using namespace std;

это группировка определенных функций, классов и т.п. Если какой-либо разработчик напишет свою библиотеку функций и в ней окажутся функции с теми же названиями, что и функции в другой библиотеке, то разработчику следует объявить уникальное пространство имен для своих функций и классов. Тогда программист, использующий такую библиотеку, сможет либо при вызове определенных функций использовать префикс пространства имен, либо объявить, что все функции по умолчанию будут вызываться из определенного пространства имен.

Подключаемые библиотечные файлы:

#include <iostream>

заголовочный файл с классами, функциями и переменными для организации ввода-вывода в языке программирования C++. Iostream использует объекты cin, cout, cerr и clog для передачи информации в и из стандартных потоков ввода и вывода. Являясь частью стандартной библиотеки C++, эти объекты также являются частью стандартного пространства имён - std.

#include <istream> Определяет класс шаблона basic_istream, которое посредничает извлечения для iostreams и класса шаблона basic_iostream, которое посредничает вставки и извлечения. Заголовок также определяет соответствующих манипулятора. Этот файл заголовка обычно включается автоматически другим заголовком iostreams; редко, необходимо включить его напрямую.

#include <conio. h>

Этот заголовочный файл объявляет несколько библиотечных функций для работы с "консольным вводом и выводом" программы. Большинство компиляторов языка Си.

#include <string>

Предназначен для добавления возможнисти использовать функции для работы со строками и т.д.

#include <windows. h>

Этот файл содержит множество определений типов данных, макросов, прототипов функций, констант и т.д.

Используемые типы:

1. int - целочисленный тип.

Формат: int name; // значение I = 0

2. string - последовательность из нуля или более символов в кодировке Юникод.

Формат: string a = "hello";

3. массивы - можно сохранить несколько переменных одного типа в структуре данных массива.

Формат: type name [];

Используемые методы:

Метод для задание входных сигналов регистра:

void RSetDirectParameters ()

{int SI=0;

cout<<"\n\n\n\t\t\t\tWrite InPuts Valuas of REGISTER: \n\n\n";

cout<<"\t\tValua of Synchro Signal = ";

cin>>SI;

cout<<"\n\t\tValua on InPut S = ";

cin>>Select;

cout<<"\n\t\tValua on InPut R = ";

cin>>Drop;

for (int i=0; i<8; i++)

{

RInput [i] [0] =SI;

RInput [i] [1] =Select;

RInput [i] [2] =Drop;

cout<<"\n\n\n\n\t\t\tWhite InPut Valuas of TRIGER MEMORY "<<i+1<<": \n";

cout<<"\n\n\t\t\tValua on InPut J = ";

cin>>RInput [i] [3];

cout<<"\n\n\t\t\tValua on InPut K = ";

cin>>RInput [i] [4];

system ("cls");

obj [i]. SetOJKDirectParameters (RInput [i] [3],RInput [i] [4],RInput [i] [0]);

obj [i]. SetORSDirectParameters (RInput [i] [1],RInput [i] [2]);

}

}

Метод для обеспечения вывода меню:

while (x! =4)

{x=5;

system ("cls");

cout<<"\n\n\t\n\tChose Digital Element Which you want to Test: ";

cout<<"\n\n\t\t1 - Combinatoric Element";

cout<<"\n\t\t2 - Memory Triger";

cout<<"\n\t\t3 - Register JK";

cout<<"\n\t\t4 - Quit\n\n\t\tAnd u chose is: ";

cin>>x;

….

}

Метод для осуществления подсчета выходного сигнала триггере JK:

int calculations ()

{

int b=0;

if (Input [0] ==1 && C==0)

{

C=0;

b=SieRa ();

if (b==1)

{cout<<"\n\t\tERROR messenge: inputs R and S have valua 1";

Input [0] =0;

Input [1] =0;

Input [2] =0;

Input [3] =0;

Input [4] =0;

}

if (b==0)

KoyJot ();

}

if (Quas==0)

Revs=1;

if (Quas==1)

Revs=0;

if (Input [0] ==0)

C=0;

}

Полный текст программы приведен в приложении.

4. Тестирование

При запуске программы, перед нами отображается окно с 4 пунктами меню. Пользователь должен ввести цифру, соответствующую нужному разделу.

В случае, если пользователь ввел цифру "1", программа запрашивает количество входов комбинационного элемента, а затем значения на его входах.

После того, как пользователь ввел все необходимые данные, он должен нажать "Enter".

Далее, перед нами появляется новое меню - подпункт раздела "Комбинационный элемент", в нем пользователю предоставляется выбор если он хочет продолжить работу с тем же комбинационным элементом он нажимает "1" и Enter, передним снова появляется окно ввода значений на входах данного комбинационного элемента и т.д.

Если он нажмет цифру "3", а затем Enter то передним откроется окно, в котором он сможет введя номер входа узнать значение его сигнала затем программа задаст вопрос хочет ли пользователь повторить предыдущею операцию "1" - да, "0" - нет. Если нет то произойдет возврат в предыдущие меню.

Если в предыдущем меню он нажмет цифру "0" и затем Enter то он вернуться в главное меню программы.

В случае если в главном меню пользователь нажмет цифру "2" и затем Enter то перед ним откроеться окно работы с триггером в котором ему будет необходимо ввести значение на входах триггра

После того как он нажмет клавишу Enter перед ним появится окно

В этом окне будет отображенна информация о значении выходного сигнала JK триггера и о значении инверсного сигнала JK триггера а так же аналогичное комбинационному элементу меню в котором он нажав цифру "3" сможет перейти к просмотру значений сигналов на входах.

Введя значение соответствующего входа из списка можно будет увидеть значение его текучего сигнала затем вопрос об повторе операции или выходе из меню и переходе к прядущему

Полсе выполнения выше изложенной операции опять появится меню выбора дейсвия если в нем ввести цифру одни то откроется окно ввода значений сигналов на входах триггера как было ранее если 0 то произойдет возврат в главное меню

Если в главном меню ввести цифру "3" и нажать клавишу Enter

Откроется окно работы с Регистром

В нем пользователю будет необходимо ввести значение синхро-сигнала поля установки и поля сброса а так же 8 пар значений регистров JK по порядку

После ввода данных откроется окно просмотра результатов в котором будет отображены значение выходов регистра и меню которое аналогичное меню из комбинационного элемента и триггера предоставляющее возможность выбора операции которая будет выполнена в дальнейшем

Если нажать "1" пользователю представиться возможность заново внести данные и просмотреть результат если "0" то произойдет возврат в главное меню если "3" то откроется меню в котором можно будет введя номер триггера который находится в составе регистра и выбрав один из его входов из списка узнать значение сигнала на данном входе.

Далее если вы нажмете ноль заново запуститься функция просмотра значения сигнала на входе если вы нажмете "0" и затем Enter то произойдет возврат в предыдущее меню

Если там вы введете цифру "0" и нажмете Enter произойдет в главное меню

Если там вы введете цифру "4" и нажмете клавишу Enter то программа завершит свою работу

Заключение

В данной работе была рассмотрена задача моделирования и создания цифровых элементов с использованием объектно-ориентированного подхода на языке программирования высокого уровня С++. На основе поставленного задания, были последовательно выполнены этапы анализа, проектирования и, на базе их результатов, произведена реализация цифровых элементов. На этапе анализа был определен внешний вид программы и компонентов логической схемы, также был приведен механизм работы с входными сигналами для более гибкого взаимодействия с пользователем. При проектирование были описаны 4 основных класса, класс ELEMENT для хранения компонентов для общего обозначения элементов, класс KOMBIN описывающий свойства и методы для работы с Комбинационным элементом "ИЛИ", класс MEMORY, послуживший основой для создания регистра, и класс REGISTER - главный класс описывающий работу сложного 8-ми разрядного Регистра памяти. При программирование класс ELEMENT был определен как шаблонный класс для всех остальных класс MEMORY стал включаемым классом для класса REGISTER.

Использование объектно-ориентированного подхода позволило значительно упростить реализацию отдельных частей данной программы, на основе чего можно сделать вывод о том, что данный подход является оптимальным для создания приложений подобного рода. Помимо этого, были закреплены навыки, полученные при выполнении лабораторных работ курса дисциплины "Объектно-ориентированное программирование", что можно также считать выполнением одной из главных целей данной работы.

Список литературы

1. http://www.petrsu.ru/Chairs/IMO/pascal/theory/part2_3_1.html

2. Буч Г., Рамбо Дж., Джекобсон А. Язык UML. Руководство пользователя. - С-П.: Издательство "Питер", 2003. - 432 с.

3. http://gos-it. wikia.com/wiki

4. http://fdpo. samgtu.ru/node/44

Приложение

#include <iostream>

#include <istream>

#include <conio. h>

#include <string>

#include <windows. h>

using namespace std;

class ELEMENT

{ private:

string name;

int AmountInput;

int AmountOutput;

public:

string GetName ()

{

return name;

}

int GetIn ()

{

return AmountInput;

}

int GetOut ()

{

return AmountOutput;

}

~ELEMENT ()

{

cout<<"\n\t\t"<<name<<" deleted";

}

ELEMENT ()

{

}

void ConfigName (string S)

{

name = S;

}

ELEMENT (string S, int K1, int K2)

{

name = S;

AmountInput = K1;

AmountOutput = K2;

}

void ConfigElement (string S, int K1, int K2)

{

name = S;

AmountInput = K1;

AmountOutput = K2; }

};

class KOMBIN: protected ELEMENT

{ private:

int* Input;

public:

KOMBIN ()

{

Input = new int [0];

}

KOMBIN (string name, int K): ELEMENT (name, K, 1)

{

Input = new int [K];

}

void SetParameters ()

{

for (int i = 0; i < GetIn (); i++)

{

cin>>* (Input+i);

}

}

int Output ()

{

int p = 0;

for (int i = 0; i < GetIn (); i++)

{

if (* (Input+i) ==1)

{

p=1; break; }

else

p=0;

}

return p;

}

int Vlinput (int x)

{int o=0;

if (x > GetIn ())

o=0;

else o=* (Input+ (x-1));

return o; }

};

class MEMORY: protected ELEMENT

{private:

int Input [5];

int Quas;

int Revs;

int C;

public:

MEMORY ()

{

for (int i = 0; i < 5; i++)

Input [i] = 0;

C=0;

Quas=0;

Revs=1;

}

MEMORY (MEMORY ob, string name): ELEMENT (name, 5,2)

{MEMORY ob1;

Quas=ob. Quas;

Revs=ob. Revs;

C=ob. C;

}

MEMORY (string name): ELEMENT (name, 5,2)

{

for (int i = 0; i < GetIn (); i++)

{

Input [i] =0;

}Quas=0; Revs=1;

C=0; }

int ReMC ()

{return C;

}

int ReSS ()

{return Input [0];

}

int ReS ()

{return Input [1];

}

int ReR ()

{return Input [2];

}

int ReJ ()

{return Input [3];

}

int ReK ()

{return Input [4];

}

void KoyJot ()

{

if (Input [3] ==0 && Input [4] ==1)

Quas=0;

if (Input [3] ==1 && Input [4] ==0)

Quas=1;

if (Input [3] ==1 && Input [4] ==1 && Quas==1)

Quas=0;

if (Input [3] ==1 && Input [4] ==1 && Quas==0)

Quas=1;

if (Input [3] ==1 && Input [4] ==1 && Revs==1)

Quas=1;

if (Input [3] ==1 && Input [4] ==1 && Revs==0)

Quas=0;

}

int SieRa ()

{int p;

p=0;

if (Input [1] ==0 && Input [2] ==0)

{

p=0; }

if (Input [1] ==1 && Input [2] ==0)

{

Quas=1; p=2; }

if (Input [1] ==0 && Input [2] ==1)

{

Quas=0; Revs=1; p=3; }

if (Input [1] ==1 && Input [2] ==1)

{

p=1; Quas=0; C=0; Revs=1; }

return p;

}

int calculations ()

{

int b=0;

if (Input [0] ==1 && C==0)

{

C=0;

b=SieRa ();

if (b==1)

{cout<<"\n\t\tERROR messenge: inputs R and S have valua 1";

Input [0] =0;

Input [1] =0;

Input [2] =0;

Input [3] =0;

Input [4] =0;

}

if (b==0)

KoyJot ();

}

if (Quas==0)

Revs=1;

if (Quas==1)

Revs=0;

if (Input [0] ==0)

C=0;

}

void SetDirectParameters ()

{cout<<"\n\n\n\t\t\tWrite InPut Valuas of MEMORY: \n"

<<"\n\t\tSynchro Impuls = ";

cin>>Input [0];

cout<<"\n\t\tValua on InPut S = ";

cin>>Input [1];

cout<<"\n\t\tValua on InPut R = ";

cin>>Input [2];

cout<<"\n\t\tValua on InPut J = ";

cin>>Input [3];

cout<<"\n\t\tValua on InPut K = ";

cin>>Input [4];

}

void SetOJKDirectParameters (int a, int b, int ss)

{ Input [3] =a;

Input [4] =b;

Input [0] =ss;

}

void SetORSDirectParameters (int a, int b)

{ Input [1] =a;

Input [2] =b;

}

int OutPut ()

{return Quas;

}

int RevsOutPut ()

{return Revs;

}

};

class REGISTER: protected ELEMENT

{

private:

int Drop;

int Select;

MEMORY obj [8];

int RInput [8] [5];

int RC;

public:

REGISTER (string name): ELEMENT (name, 40, 16)

{

Drop=0;

Select=0;

RC=0;

for (int i=0; i<8; i++)

{for (int j=0; j<5; j++)

{RInput [i] [j] =0; }}

}

int OutInput (int r, int e)

{

e=e-1;

r=r-1;

return RInput [r] [e];

}

void RSetDirectParameters ()

{int SI=0;

cout<<"\n\n\n\t\t\t\tWrite InPuts Valuas of REGISTER: \n\n\n";

cout<<"\t\tValua of Synchro Signal = ";

cin>>SI;

cout<<"\n\t\tValua on InPut S = ";

cin>>Select;

cout<<"\n\t\tValua on InPut R = ";

cin>>Drop;

for (int i=0; i<8; i++)

{

RInput [i] [0] =SI;

RInput [i] [1] =Select;

RInput [i] [2] =Drop;

cout<<"\n\n\n\n\t\t\tWhite InPut Valuas of TRIGER MEMORY "<<i+1<<": \n";

cout<<"\n\n\t\t\tValua on InPut J = ";

cin>>RInput [i] [3];

cout<<"\n\n\t\t\tValua on InPut K = ";

cin>>RInput [i] [4];

system ("cls");

obj [i]. SetOJKDirectParameters (RInput [i] [3],RInput [i] [4],RInput [i] [0]);

obj [i]. SetORSDirectParameters (RInput [i] [1],RInput [i] [2]);

}

}

void RegisterCalculations ()

{

RSetDirectParameters ();

system ("cls");

cout<<"\n\t\t\tOutPut value of REGISTER Outputs: \n ";

for (int i=0; i<8; i++)

{

if (RInput [i] [0] ==1 && RC==0)

{

obj [i]. calculations ();

}

cout<<"\n\t\tMEMORY No. "<<i+1<<" is "<<obj [i]. OutPut () <<" "<<"Reverse is "<<obj [i]. RevsOutPut ();

}

if (RInput [0] [0] ==0)

RC=0;

if (RInput [0] [0] ==1)

RC=1;

}

};

int main ()

{

int m=0; int n=0; int g=0; int v=0;

cout<<"\n\n\t\t\tWellcome to NOIR's Course Project!";

int x=0;

while (x! =4)

{x=5;

system ("cls");

cout<<"\n\n\t\n\tChose Digital Element Which you want to Test: ";

cout<<"\n\n\t\t1 - Combinatoric Element";

cout<<"\n\t\t2 - Memory Triger";

cout<<"\n\t\t3 - Register JK";

cout<<"\n\t\t4 - Quit\n\n\t\tAnd u chose is: ";

cin>>x;

if (x==1)

{int x1=1;

system ("cls");

cout<<"\n\n\n\t\tWrite amount inputs of combination element ";

cin>>n;

KOMBIN ob ("Richard",n);

cout<<"\n\t\tWrite value of inputs ";

ob. SetParameters ();

cout<<"\n\t\t"<<"OutPut's value of combination element is "<<ob. Output ();

while (x1! =0)

{

cout<<"\n\n\t\tDo you want continue work with this element? 1-yes / 0-no\n\t\tif you want inspect values on inputs type - 3 \n\t\t";

cin>>x1;

system ("cls");

if (x1==1)

{

system ("cls");

cout<<"\n\n\n\n\n\t\tWrite value of inputs ";

ob. SetParameters ();

cout<<"\n\t\t"<<"OutPut's value of combination element is "<<ob. Output ();

}

if (x1==3)

{int x2=1;

while (x2! =0)

{system ("cls");

cout<<"\n\n\n\t\twrite No. of Input which u want inspect ";

cin>>m;

cout<<"\n\t\tvalue of input No. "<<m<<" is "<<ob. Vlinput (m);

cout<<"\n\t\tdo you want to do it again? 1 - yes 0 - no ";

cin>>x2;

}

}

}

system ("cls");

}

if (x==2)

{int x3=1;

system ("cls");

MEMORY og ("Charls");

cout<<"\n\n\t\t";

og. SetDirectParameters ();

og. calculations ();

cout<<"\n\t\tOutPut value of MEMORY is "<<og. OutPut () <<"\n"<<"\t\tReversive OutPut value of MEMORY is "<<og. RevsOutPut ();

while (x3! =0)

{

cout<<"\n\n\t\tDo you want continue work with this element? 1-yes / 0-no\n\t\tif you want inspect values on inputs type - 3 \n\t\tand you answer is: ";

cin>>x3;

if (x3==1)

{system ("cls");

cout<<"\n\n\t\t";

og. SetDirectParameters ();

og. calculations ();

cout<<"\n\t\tOutPut value of MEMORY is "<<og. OutPut () <<"\n"<<"\t\tReversive OutPut value of MEMORY is "<<og. RevsOutPut () <<"\n";

}

if (x3==3)

{system ("cls");

int x4=1;

while (x4! =0)

{system ("cls");

cout<<"\n\n\n\t\twrite No. of Input which u want inspect from list\n\n\t\t 1. Synchro Impulse 2. S 3. R 4. J 5. K 6. Memory Sync \n\n\t\t Input: ";

cin>>v;

if (v==1)

cout<<"\n\t\tVALUE of input Synchro Impulse is "<<og. ReSS ();

if (v==2)

cout<<"\n\t\tVALUE of input S is "<<og. ReS ();

if (v==3)

cout<<"\n\t\tVALUE of input R is "<<og. ReR ();

if (v==4)

cout<<"\n\t\tVALUE of input J is "<<og. ReJ ();

if (v==5)

cout<<"\n\t\tVALUE of input K is "<<og. ReK ();

if (v==6)

cout<<"\n\t\tVALUE of input Memory Sync is "<<og. ReMC ();

cout<<"\n\n\t\tdo you want to do it again? 1 - yes 0 - no \n\n\t\t and you answer is: ";

cin>>x4;

system ("cls");

}}}}

if (x==3)

{system ("cls");

int x5=1;

REGISTER osh ("Elisabeth");

osh. RegisterCalculations ();

while (x5! =0)

{

cout<<"\n\n\t\tDo you want continue work with this element? 1-yes / 0-no\n\t\tif you want inspect values on inputs type - 3 \n\t\tand you answer is: ";

cin>>x5;

if (x5==1)

{

system ("cls");

cout<<"\n\n\t\t";

osh. RegisterCalculations ();

}

if (x5==3)

{

int x6=1;

int z=0;

system ("cls");

while (x6! =0)

{cout<<"\n\n\n\t\twrite No. of MEMORY which you want inspect: ";

cin>>z;

cout<<"\n\n\t\twrite No. of Input which u want inspect from list\n\n\t\t 1. Synchro Impulse 2. S 3. R 4. J K.5\n\n\t\t Input: ";

cin>>v;

if (v==1)

cout<<"\n\t\tVALUE of input Synchro Impulse of REGISTER' MEMORY "<<z<<" is "<<osh. OutInput (z,v);

if (v==2)

cout<<"\n\t\tVALUE of input S of REGISTER' MEMORY "<<z<<" is "<<osh. OutInput (z,v);

if (v==3)

cout<<"\n\t\tVALUE of input R of REGISTER' MEMORY "<<z<<" is "<<osh. OutInput (z,v);

if (v==4)

cout<<"\n\t\tVALUE of input J of REGISTER' MEMORY "<<z<<" is "<<osh. OutInput (z,v);

if (v==5)

cout<<"\n\t\tVALUE of input K of REGISTER' MEMORY "<<z<<" is "<<osh. OutInput (z,v);

cout<<"\n\n\t\tdo you want to do it again? 1 - yes 0 - no \n\n\t\t and you answer is: ";

cin>>x6;

system ("cls");

}}}}}

return 0; }

Размещено на Allbest.ru


Подобные документы

Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д.
PPT, PPTX и PDF-файлы представлены только в архивах.
Рекомендуем скачать работу.