(5 оценок, среднее: 4,80 из 5)
Загрузка...
Учебная работа. Курсовая работа: Класс «Грузовой лифт»
Тульский муниципальный институт
Кафедра автоматики и телемеханики
Класс «Грузовой лифт»
Объяснительная записка
к контрольно-курсовой работе
по курсу «Объектно-ориентированное программирование»
Выполнила: студентка группы 220622
Павликова М. В.
Проверил: доцент кафедры АТМ
Середин О. С.
Тула 2004
Инструкция
В контрольно-курсовой работе рассмотрена задачка сотворения класса «грузовой лифт» и описания операций над данным классом. Эта задачка была спроектирована с внедрением концепций объектно-ориентированного программирования и реализована на языке программирования С++. Объяснительная записка содержит 26 листов, 5 рисунков и 3 использованных источника.
Содержание
Стр.
Введение…………………………………………………………………………………………….. 3
Постановка задачки……………………………………………………………………………… 5
Построение абстрактной модели класса «грузовой лифт»……………………… 6
2.1 Построение диаграммы классов……………………………………………………… 9
2.2 Построение диаграммы модулей…………………………………………………… 10
структура класса «грузовой лифт»……………………………………………………. 11
3.1Формальное описание класса………………………………………………………… 11
3.2 Описание структур данных…………………………………………………………… 13
3.3 инструкция программеру…………………………………………………………… 21
Демо программка…………………………………………………………… 22
4.1текст программки………………………………………………………………………….. 22
4.2 инструкция юзеру……………………………………………………………. 22
Тестовый пример………………………………………………………………………………. 23
Заключение………………………………………………………………………………………. 25
Перечень использованных источников…………………………………………………… 26
Введение
Объектно-ориентированное программирование – это новейший подход к созданию программ. По мере развития вычислительной техники появлялись различные методики программирования. На любом шаге создавался новейший подход, который помогал программерам управляться с возрастающим усложнением программ. 1-ые программки создавались средством главных переключателей на фронтальной панели компа. Разумеется, что таковой метод подступает лишь для весьма маленьких программ. Потом был изобретён язык ассемблера, который дозволял писать наиболее длинноватые программки. Последующий шаг был изготовлен в 1950 году, когда был сотворен 1-ый язык высочайшего уровня Фортран.
Используя язык высочайшего уровня, программеры могли писать программки до нескольких тыщ строк длиной. Для того времени обозначенный подход к программированию был более многообещающим. Но язык программирования, просто понимаемый в маленьких программках, когда дело касалось огромных программ, становился нечитабельным (и неуправляемым). Избавление от таковых неструктурированных программ пришло опосля изобретения в 1960 году языков структурного программирования. К ним относятся языки Алгол, Паскаль, и С. Структурное программирование предполагает буквально обозначенные управляющие структуры, программные блоки, отсутствие (либо, по последней мере, малое внедрение) инструкций GOTO, автономные подпрограммы, в каких поддерживается рекурсия и локальные переменные. Сущностью структурного программирования является возможность разбиения программки на составляющие элементы. Используя структурное программирование, программер может создавать и поддерживать программки выше 50000 строк длинноватой.
Хотя структурное программирование, при его использовании для написания равномерно сложных программ, принесло выдающиеся результаты, даже оно оказывалось несостоятельным тогда, когда программка достигала определённой длины. Чтоб написать наиболее сложную программку, нужен был новейший подход к программированию. В итоге были разработаны принципы объектно–нацеленного программирования. ООП аккумулирует наилучшие идеи, воплощённые в структурном программировании, и соединяет их с массивными новенькими концепциями, которые разрешают нормально организовывать ваши программки. Объектно-ориентированное программирование дозволяет для вас разложить делему на составные части. Любая составляющая становится самостоятельным объектом, содержащим свои собственные коды и данные, которые относятся к этому объекту. В этом случае вся процедура в целом упрощается, и программер получает возможность оперировать с еще большенными по объёму программками.
Все языки ООП основаны на трёх основополагающих концепциях, именуемых инкапсуляцией, полиморфизмом и наследованием:
Инкапсуляция – это механизм, который соединяет воединыжды данные и код, манипулирующий с этими данными, также защищает и то, и другое от наружного вмешательства либо неверного использования.
Полиморфизм – это свойство, которое дозволяет одно и то же имя применять для решения 2-ух либо наиболее похожих, но на техническом уровне различных задач. Целью полиморфизма, применительно к объектно-ориентированному программированию, является внедрение 1-го имени для задания общих для класса действий.
Наследование – это процесс, средством которого один объект может получать характеристики другого. Поточнее, объект может наследовать главные характеристики другого объекта и добавлять к ним черты, соответствующие лишь для него.
В контрольно-курсовой работе реализуем класс «грузовой лифт». Лифты можно подразделять по огромному количеству признаков, к примеру: грузовые и легковые, пассажирские и непассажирские и т. д. В данном случае будет написан класс для демонстрации работы лифта для перевозки груза в сопровождении человека. В качестве характеристик работы лифта будут применены: грузоподъёмность, Политика обслуживания запросов (останавливаться ли на промежных этажах), количество этажей в здании и активация неопасного режима работы. Данный класс быть может применен в аппаратуре управления лифтом, т. к. быть может настроен на определенные условия работы. В качестве демонстрационной программки покажем порядок выполнения запросов при различных настройках лифта и различных входных данных.
1. Постановка задачки
Требуется сделать класс «лифт», в каком будет реализована базисная функциональность лифта, потом сделать производный от него класс «грузовой лифт». Класс должен быть настраиваемым на определенные условия работы. Параметрами таковой опции могут быть: количество этажей в здании, политика обслуживания запросов, грузоподъёмность лифта и т. д. Должны быть обмыслены вопросцы сохранности и оптимизации работы лифта.
2. Построение абстрактной модели
класса «грузовой лифт»
Сначала работы сотворен базисный класс «лифт», реализующий основную функциональность лифта.
Наряду с базисным классом сотворен класс «груз» со последующими членами класса:
· этаж, на котором находится груз;
· этаж, на котором ему необходимо оказаться;
· вес груза.
На базе классов «лифт» и «груз» сделаем класс «грузовой лифт». Этот класс будем наследовать от класса «лифт», а одним из членов этого класса будет массив из частей класса «груз».
Приведём описание класса «лифт»:
class lift
{
float weight;//грузоподъемность
int height;//кол-во этажей
bool stop;//остановка на промежных этажах
float weight_load;//вес груза
float exc_weight;//превышение грузоподъемности
bool safety;//активация сохранности
public:
lift();
void put_weight(float weigh);
void put_h(int h);
void put_stop(bool stp);
void put_wload(float weigh);
void put_excess(float exc);
void put_safety(bool saf);
float get_weight();
int get_h();
bool get_stop();
float get_wload();
float get_excess();
bool get_safety();
void global_tuning();
};
Класс имеет последующие члены-данные:
weight – грузоподъёмность лифта;
height – высота дома, в каком эксплуатируется лифт (количество этажей);
stop – Политика обслуживания запросов (останавливаться ли на промежных этажах);
weight_pas – вес пассажиров и груза, находящихся в лифте;
exc_weight – допустимое превышение грузоподъёмности лифта;
safety – активация неопасной работы лифта.
Также в классе определены последующие операции над членами-данными:
· установка и возврат значений членов-данных;
· настройка лифта перед пуском в эксплуатацию;
· подъём и спуск кабины лифта;
· подсвечивание датчиков положения лифта на этаже, открытия дверей и сообщения о перегрузке.
Дальше приведём описание класса «груз»:
class load
{
int first_floor;//исходный этаж
int last_floor;//конечный этаж
float weight_load;//вес сопровождаемого груза
float pas_weight;//вес пассажира
bool in_lift;//в лифте
bool out_lift;//вне лифта
public:
load();
void put_first(int floor);
void put_last(int floor);
void put_load(float car);
void put_in(bool in);
void put_out(bool out);
int get_first();
int get_last();
float get_load();
float get_pweight();
bool get_in();
bool get_out();
};
Класс имеет последующие члены-данные:
first_floor – этаж, на котором находится груз перед отправкой;
last_floor – этаж, на котором должен оказаться груз;
weight_load – вес груза;
pas_weight – вес пассажира, провождающего груз;
in_lift – нахождение груза в лифте;
out_lift – нахождение груза вне лифта.
В классе определены операции установки и возврата значений членов-данных.
На базе прошлых 2-ух классов получим класс «грузовой лифт». Описание класса приведено ниже:
class car_lift: public lift
{
load *cargo;//массив грузов
int qual;//количество вызовов
public:
car_lift();
~car_lift();
int get_first(int k);
int get_last(int k);
float get_load(int k);
float get_pweight(int k);
bool get_in(int k);
bool get_out(int k);
void put_load(int ql);
void turning();
void entry(load &l);
void out(load &l);
void overl(int floor);
void work();
};
В классе определены члены-данные:
сargo – массив частей класса «груз»;
qual – количество человек вызовов лифта.
Над членами-данными класса определены последующие операции:
· установка количества пассажиров, ожидающих лифт;
· ввод данных для работы лифта;
· изменение членов-данных класса в связи со входом пассажира в лифт;
· изменение членов-данных класса в связи с выходом пассажира из лифта;
· изменение членов-данных класса в связи с перегрузкой лифта;
· движение лифта.
2.1 Построение диаграммы классов
Диаграмма классов указывает классы и их дела, тем, представляя логический нюанс проекта. Отдельная диаграмма классов представляет определенный ракурс структуры классов. На стадии анализа употребляются диаграммы классов, чтоб выделить общие роли и обязанности сущностей, обеспечивающих требуемое системы.
Два основных элемента диаграммы классов — это классы и их главные дела.
Главные атрибуты и функции данных классов, также их связь и иерархию комфортно показать на диаграмме классов (набросок 2.1).
Рис. 2.1 – Диаграмма классов для объекта «грузовой лифт»
2.2 Построение диаграммы модулей
Диаграмма модулей указывает распределение классов и объектов по модулям в физическом проектировании системы. Любая отдельная диаграмма модулей представляет некий ракурс структуры модулей системы. При разработке мы используем диаграмму модулей, чтоб показать физическое деление нашей архитектуры по слоям и разделам. Главными элементами диаграммы модулей являются модули и их зависимости.
Единственная связь, которая может существовать меж 2-мя модулями, — компиляционная зависимость — представляется стрелкой, выходящей из зависимого модуля. В C++ таковая зависимость указывается директивой #include. В огромном количестве компиляционных зависимостей не могут встречаться циклы. Чтоб найти частичную упорядоченность компиляций, довольно выполнить частичное упорядочение структуры модулей системы.
На рисунке 2.2 показана диаграмма модулей для нашей задачки.
Рис. 2.2 – Диаграмма модулей
3. структура класса «грузовой лифт»
3.1 Формальное описание класса
Дальше приведены заголовочные h –файлы с комментами.
Заголовочный файл класса «груз»:
class load
{
int first_floor;//исходный этаж
int last_floor;//конечный этаж
float weight_load;//вес груза
float pas_weight;//веспассажира
bool in_lift;//влифте
bool out_lift;//внелифта
public:
load();//конструктор
void put_first(int floor);//установка исходного этажа
void put_last(int floor);//установка конечного этажа
void put_load(float car);//установкавесагруза
void put_in(bool in);//установка нахождения груза в лифте
void put_out(bool out);//установка нахождения груза вне лифта
int get_first();//возврат исходного этажа
int get_last();//возврат конечного этажа
float get_load();//возврат веса груза
float get_pweight();//возврат веса пассажира
bool get_in();//возврат нахождения груза в лифте
bool get_out();//возврат нахождения груза вне лифта
};
Заголовочный файл класса «лифт»:
class lift
{
float weight;//грузоподъемность
int height;//кол-во этажей
bool stop;//остановка на промежных этажах
float weight_load;//вес груза и пассажиров в лифте
float exc_weight;//превышение грузоподъемности
bool safety;//активация сохранности
public:
lift();//конструктор
void put_weight(float weigh);//установка грузоподъемности
void put_h(int h);//установка количества этажей
void put_stop(bool stp);//установка политики обслуживания
(останавливаться ли на промежных этажах)
void put_wload(float weigh);//установка веса груза и пассажиров в лифте
void put_excess(float exc);//установка превышения грузоподъемности
void put_safety(bool saf);//установка сохранности
float get_weight();//возврат грузоподъемности
int get_h();//возврат количества этажей
bool get_stop();//возврат политики обслуживания
float get_wload();//возврат веса груза и пассажиров в лифте
float get_excess();//возврат превышения грузоподъемности
bool get_safety();//возврат сохранности
void global_tuning();//настройка лифта
};
Заголовочный файл класса «грузовой лифт»:
class car_lift: public lift
{
load *cargo;//массив грузов
int qual;//количество вызовов
public:
car_lift();
~car_lift();
int get_first(int k);//возврат исходного этажа
int get_last(int k);//возврат конечного этажа
float get_load(int k);//возврат веса груза
float get_pweight(int k);//возврат веса пассажира
bool get_in(int k);//возврат нахождения груза в лифте
bool get_out(int k);//возврат нахождения груза вне лифта
void put_load(int ql);//установка количества вызовов
void turning();//ввод данных для работы лифта
void entry(load &l);//вход пассажира из лифта
void out(load &l);//выход пассажира из лифта
void overl(int floor);//временный выход пассажира в связи с перегрузкой
void work();//работа лифта
};
3.2 Описание структур данных
Дальше приведено описание структур данных и функций применяемых классов.
· void global_turning()
Функция употребляется для глобальной опции работы лифта. Пример реализации функции приведён ниже:
void lift::global_tuning()
{
clrscr();
float f_number=0;
int i_number=0;
cout<<«Глобальная настройка работы лифта:»<<endl;
do
{
cout<<«Грузоподъемность лифта(кг): «;
cin>>f_number;
if(f_number<=0)
cout<<«Грузоподъемность обязана быть больше 0″<<endl;
} while (f_number<=0);
put_weight(f_number);
cout<<«Активировать сохранность?(‘да’-1) «;
cin>>i_number;
if(i_number==1) put_safety(true);
else put_safety(false);
if(get_safety()==false)
{
do
{
cout<<«Допустимое превышение грузоподъемности(кг): «;
cin>>f_number;
if(f_number<0)
cout<<«Превышение грузоподъемности обязано быть положительным»<<endl;
} while (f_number<0);
put_excess(f_number);
}
do
{
cout<<«количество этажей в здании: «;
cin>>i_number;
if(i_number>25) cout<<«количество этажей обязано быть меньше 25″<<endl;
} while (i_number>25);
put_h(i_number);
cout<<«Останавливаться на промежных этажах?(‘да’-1) «;
cin>>i_number;
if(i_number==1) put_stop(true);
else put_stop(false);
}
В данной реализации делается проверка вводимых значений, чтоб избежать неправильных данных. к примеру, грузоподъёмность лифта обязана быть положительной (больше 0), а количество этажей в здании, в каком эксплуатируется лифт, меньше 25 (это соединено демонстрационной программкой).
· int up(int a, int b)
Функция употребляется для подъёма кабины лифта с этажа a на этаж b. Пример реализации функции приведён ниже:
int up(int a, int b)
{
char num[10];
delay(4000);
setcolor(0);
outtextxy(25,47,»Двериоткрыты!»);
int x=5+(a-1)*25;
for(int i=a;i<=b;i++)
{
setcolor(15);
itoa(i,num,10);
outtextxy(x+6,15,num);
if(i>a)
{
setcolor(8);
itoa(i-1,num,10);
outtextxy(x-19,15,num);
}
x+=25;
delay(2000);
}
setcolor(15);
rectangle(5,40,150,60);
setcolor(15);
outtextxy(25,47,»Двериоткрыты!»);
return b;
}
В данной реализации функция только подсвечивает номера этажей во время движения. А опосля прибытия лифта подсвечивает надпись «Двери открыты!».
· int down(int a, int b)
Функция употребляется для спуска кабины лифта с этажа a на этаж b. Пример реализации функции приведён ниже:
int down(int a, int b)
{
char num[10];
delay(4000);
setcolor(0);
outtextxy(25,47,»Двериоткрыты!»);
int x=5+(a-1)*25;
for(int i=a;i>=b;i—)
{
setcolor(15);
itoa(i,num,10);
outtextxy(x+6,15,num);
if(i<a)
{
setcolor(8);
itoa(i+1,num,10);
outtextxy(x+31,15,num);
}
x-=25;
delay(2000);
}
setcolor(15);
rectangle(5,40,150,60);
setcolor(15);
outtextxy(25,47,»Двериоткрыты!»);
return b;
}
Функция схожа функции подъёма лифта.
· void turning()
Функция употребляется для ввода данных нужных для работы лифта. Пример реализации функции приведён ниже:
void car_lift::turning()
{
float f_number=0;
int i_number=0;
cout<<«Ввод нужных данных!»<<endl;
cout<<«Введите количество человек, ожидающих лифт: «;
cin>>i_number;
put_load(i_number);
for(int i=0; i<qual; i++)
{
cout<<i+1<<«-ыйвызов:»<<endl;
do
while((i_number<=0)||(i_number>get_h()));
cargo[i].put_first(i_number);
do
while((i_number<=0)||(i_number>get_h())||(i_number==cargo[i].get_first()));
cargo[i].put_last(i_number);
do
{
cout<<«Весгруза(кг): «;
cin>>f_number;
if(f_number<0)
cout<<«Вес должен быть положительным!»<<endl;
if(f_number>get_weight()-cargo[i].get_pweight())
cout<<«Лифт не сумеет поднять этот груз!»<<endl;
} while((f_number<=0)||(f_number>get_weight()-cargo[i].get_pweight()));
cargo[i].put_load(f_number);
}
}
В данной реализации делается проверка вводимых значений, чтоб избежать неправильных данных. к примеру, задаваемые этажи должны быть в спектре от 1 до крайнего в данном здании, исходный и конечный этажи не должны совпадать, вес сопровождаемого груза должен быть больше нулевого и суммарный вес груза и провождающего его человека не должен быть больше грузоподъёмности лифта.
· void entry(load &l)
Функция производит изменение членов данных класса в связи со входом пассажира в лифт. Пример реализации функции приведён ниже:
void car_lift::entry(load &l)
{
l.put_in(true);
l.put_out(false);
put_wload(get_wload()+l.get_pweight()+l.get_load());
}
В данной реализации функция записывает
· void out(load &l)
Функция производит изменение членов данных класса в связи с выходом пассажира из лифта. Пример реализации функции приведён ниже:
void car_lift::out(load &l)
{
l.put_in(false);
l.put_out(false);
put_wload(get_wload()-l.get_pweight()-l.get_load());
}
В данной реализации функция записывает
· void overl(int floor)
Функция производит изменение членов-данных класса в связи с временным выходом пассажира из лифта из-за перегрузки. Пример реализации функции приведён ниже:
void car_lift::overl(int floor)
{
grow_overl();
closegraph();
int i_number;
bool buf=true;
cout<<«Перегрузка!!! один человек должен выйти!!!»<<endl;
do
{
cout<<«Введите номер пассажира, который выйдет»<<endl;
cin>>i_number;
buf=cargo[i_number-1].get_in();
if(cargo[i_number-1].get_in()==false) cout<<«Такогопассажиравлифтенет!»<<endl;
else
{
cargo[i_number-1].put_in(false);
cargo[i_number-1].put_out(true);
cargo[i_number-1].put_first(floor);
put_wload(get_wload()-cargo[i_number-1].get_pweight()-cargo[i_number1].get_load());
}
} while(buf==false);
init_graph();
grow(get_h());
}
· void work()
Функция производит работу лифта зависимо от глобальной опции и входных данных. Пример реализации функции приведён ниже:
void car_lift::work()
{
int first;
int last;
int sum=0;
int i_number;
int j;
bool over_l=false;
grow(get_h());
do
{
sum=0;
if(get_wload()==0)//грузавлифтенет
{
j=0;
while((cargo[j].get_out()==false)&&(j<qual)) j++;
first=cargo[j].get_first();
last=cargo[j].get_last();
entry(cargo[j]);
}
if(over_l==false)
{
for(int i=0;i<qual;i++)//проверка наличия вызовов на данном этаже
{
if((cargo[i].get_out()==true)&&(cargo[i].get_first()==first))
entry(cargo[i]);
}
}
if(last>first)//движениенаподъем
{
if(get_stop()==true)
{
for(int i=0;i<qual;i++)//естьливызовынапромежуточныхэтажах
{
if((cargo[i].get_in()==true)&&(cargo[i].get_last()<last)&&
(cargo[i].get_last()>first))
last=cargo[i].get_last();
if((cargo[i].get_out()==true)&&(cargo[i].get_first()<last)&&
(cargo[i].get_first()>first))
last=cargo[i].get_first();
}
}
if (get_wload()>get_weight())//проверканаперегрузку
{
overl(first);
over_l=true;
}
else
{
first=up(first,last);//подъем
over_l=false;
}
}
else//движение на спуск
{
if(get_stop()==true)
{
for(int i=0; i<qual; i++)//естьливызовынапромежуточныхэтажах
{
if((cargo[i].get_in()==true)&&((cargo[i].get_last()>last)&&
(cargo[i].get_last()<first)))
last=cargo[i].get_last();
if((cargo[i].get_out()==true)&&((cargo[i].get_first()>last)&&
(cargo[i].get_first()<first)))
last=cargo[i].get_first();
}
}
if(get_wload()>get_weight())//проверканаперегрузку
{
overl(first);
over_l=true;
}
else
{
first=down(first,last);//спуск
over_l=false;
}
}
for(int i=0; i<qual; i++)//желает ли кто-либо выйти на данном этаже
{
if((cargo[i].get_in()==true)&&(cargo[i].get_last()==first))
{
out(cargo[i]);
}
}
if(over_l==false)
{
for(i=0;i<qual;i++)//есть ли вызовы на данном этаже
{
if((cargo[i].get_out()==true)&&(cargo[i].get_first()==first))
{
entry(cargo[i]);
}
}
}
j=0;
while((cargo[j].get_in()==false)&&(j<qual)) j++;
last=cargo[j].get_last();//определение последующего этажа,
//есливлифтеестьгруз
for(i=0; i<qual; i++)
if((cargo[i].get_out()==true)||(cargo[i].get_in()==true)) sum++;
if((get_wload()==0)&&(sum>0))//определение движения,
//если в лифте нет груза
{
j=0;
while((cargo[j].get_out()==false)&&(j<qual)) j++;
last=cargo[j].get_first();
if(last>first) up(first,last);
else down(first,last);
}
} while(sum>0);//покаестьвызовы
delay(2000);
outtextxy(25,70,»Работа завершена! Нажмите ‘Enter'»);
}
В данной реализации функция описывает порядок обслуживания вызовов зависимо от глобальной опции лифта и входных данных. Работа лифта задаётся циклом с операциями в последующем порядке:
1. задаётся направление движения лифта;
2. проверяется наличие вызовов на данном этаже;
3. проверяется, есть ли груз, для которого этот этаж конечный;
4. проверяется наличие вызовов на промежных этажах;
5. проверяется превышение грузоподъёмности;
6. осуществляется движение.
Цикл производится до того времени, пока не будут обслужены все вызовы.
3.3 инструкция программеру
При написании класса «грузовой лифт» были применены последующие классы:
· класс «груз», описывающий главные функции объекта «груз для перевозки». Этот класс употребляется для сотворения массива вызовов для грузового лифта;
· класс «лифт», описывающий основную функциональность лифта. Этот класс наследуется классом «грузовой лифт» с добавлением членов-данных и членов функций.
Класс «грузовой лифт» предназначен для определения порядка обслуживания вызовов зависимо от глобальной опции лифта. Для наглядности кода был определён новейший тип данных – bool, для работы с логическими переменными.
Особенное требование при работе с классом: потому что функция work() работает в графическом режиме, нужно вызывать функцию init_graph() перед вызовом функции work().
4. Демо программка
4.1 текст программки
Дальше приведена программка, демонстрирующая работу грузового лифта. Программка находится в файле lift_main.cpp.
voidmain()
{
clrscr();
int i_number=0;
int ch;
car_lift elevator;
elevator.global_tuning();
do
{
elevator.turning();
init_graph();
elevator.work();
getch();
closegraph();
cout<<«Продолжить работу?(y-да)»<<endl;
ch=getch();
} while (ch==121);
}
4.2 инструкция юзеру
программка показывает работу грузового лифта. Для начала работы нужно запустить файл lift_main.exe. Опосля что, следуя указаниям программки, нужно произвести настройку работы лифта (эта настройка будет действовать в течение всей работы программки) и ввести начальные данные для работы. Опосля окончания работы с одними данными, можно продолжить работу, введя новейшие. При вводе неправильной инфы, программка выдаст предупреждение и можно будет повторить ввод. Для конфигурации опций лифта, нужно запустить программку поновой.
5. Тестовый пример
Опосля пуска файла lift_main.exe нужно произвести настройку лифта:
Глобальная настройка работы лифта:
Грузоподъемность лифта (кг): 500
Активировать сохранность? (‘да’-1) 1
количество этажей в здании: 15
Останавливаться на промежных этажах? (‘да’-1) 1
Потом ввести нужные данные:
Ввод нужных данных!
Введите количество человек, ожидающих лифт: 3
1-й вызов:
Исходный этаж: 1
Конечный этаж: 3
Вес груза (кг): 200
2-й вызов:
Исходный этаж: 2
Конечный этаж: 5
Вес груза (кг): 100
3-й вызов:
Исходный этаж: 2
Конечный этаж: 8
Вес груза (кг): 100
Во время работы программки на дисплее возникает последующая картина:
1. Вид экрана во время движения лифта (см. рис. 5.1)
Рис. 5.1 — движение лифта
2. Вид экрана во время остановки лифта (см. рис. 5.2)
Рис. 5.2 – Остановка лифта
3. Вид экрана в момент перегрузки лифта (см. рис. 5.3)
Рис. 5.3 – Перегрузка лифта
Результаты работы программки:
Движение лифта: 1 – 2;
Перегрузка!!! один человек должен выйти!!!
Введите номер пассажира, который выйдет: 1
2 – 5; 5 – 8; 8 – 2; 2 – 3.
Заключение
В курсовой работе был сотворен класс «грузовой лифт», путём наследования от класса «лифт» и использования экземпляра класса «груз». На базе сделанного класса была написана демо программка, показывающая работу грузового лифта в графическом режиме. Класс «грузовой лифт» быть может настроен на определенные условия работы. Параметрами опции служат:
· грузоподъёмность лифта;
· высота строения, в каком эксплуатируется лифт;
· Политика обслуживания вызовов (останавливаться ли на промежных этажах);
· активация неопасного режима работы.
В классе обмыслена оптимизация работы лифта, которая базируется не только лишь на скорости работы, да и на удобстве пассажиров.
Перечень использованных источников
1. Буч Г. Объектно-ориентированный анализ и проектирование с примерами приложений на С++, 2-е изд./ Пер. с англ.- М.: БИНОМ, 560 с.
2. Климова Л.М. Базы практического программирования на языке С++ -М.: “Издательство ПРИОР”, 1999, 464с.
3. Шилдт Г. Самоучитель С++: Пер. с англ. — 3-е изд. – СПб.: БХВ-Петербург, 2004, 688 с.
]]>