Курсовая работа: Проектирование и разработка классов средствами языка программирования С++Builder6/0
МИНИСТЕРСТВО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ
Государственное образовательное учреждение
Высшего профессионального образования
"Кубанский государственный технологический университет"
(КубГТУ)
Армавирский механико-технологический институт
Кафедра внутризаводского электрооборудования и автоматики
ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к курсовому проекту
по дисциплине Объектно-ориентированное программирование
на тему "Проектирование и разработка абстрактных типов данных средствами языка программирования C++ Builder 6/0"
Выполнил студент группы
Руководитель (нормоконтроллер)
проекта доц. каф.
Защищен
Армавир 2010 г.
Содержание задания: Создать класс wind, характеризующий ветровой режим. Класс должен содержать два поля типа int для хранения значений направления (0˚<dd<360˚) и модуля скорости ветра (V км/час). Поля объектов инициализировать конструктором по умолчанию и конструктором с двумя параметрами. Класс должен содержать константные методы вывода значений характеристик ветра в формате (dd-V), а также каждой характеристики в отдельности и метод, вычисляющий значения составляющих скорости по известным значениям модуля и направления (u=Vcos (dd), v=Vsin (dd)). Написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind). Интерфейс программы построить с использованием визуальных компонентов библиотеки VCL.
Объем работы 25-30 листов.
Рекомендуемая литература:
Архангельский А.Я. Программирование в C++ Builder 6. - М.: ЗАО "Издательство БИНОМ". 2003. - 1152 с.: ил.
Иванова П.С. Объектно-ориентированное программирование: Учебник для ВУЗов. - М.: Изд. МГТУ им Н.Э. Баумана. 2001. - 320с.: ил.
Шамис В.А. Borland C++Builder 6/0 для профессионалов. - СПб.: Питер, 2003. - 798 с.: ил.
Срок выполнения проекта с
Дата выдачи задания
Руководитель проекта доцент кафедры ВЭА ____________
Задание принял студент ___________________
Реферат
Курсовая работа: 27 с., 6 рис., 2 прил., 1 прогр.
КЛАСС WIND, ОБЪЕКТ, C++BUILDER 6.
Цель работы: закрепить навыки проектирования и разработки классов; разработать абстрактный тип данных (класс), характеризующий ветровой режим, написать программу, демонстрирующую применение разработанного класса.
Задачи:
спроектировать класс wind, построить UML - диаграмму проектируемого класса,
для инициализации полей объектов использовать конструктор по умолчанию и конструктор с параметрами, организовать вывод значений характеристик ветра в формате dd-V, а также преопределенную операцию слоения),
написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind).,
В результате выполнения курсовой работы
закреплены навыки построения классов и использования механизмов инкапсуляции и полиморфизма,
написан программный модуль на языке программирования C++ в среде программирования C++Buiilder 5/0 демонстрирующая работу с классом wind, разработано руководство по применению программы.
Содержание
1. Теоретические аспекты объектно-ориентированного программирования
1.1 Основные понятия объектно-ориентированного программирования
2. Предложения по решению поставленной задачи
2.1 Предметная область программирования. Ветровой режим
2.2 Атрибуты и методы класса. UML-диаграмма
2.3 Описание использованных компонентов библиотеки VCL
2.4 Проектирование пользовательского интерфейса. Объектная декомпозиция
3.2 Результат тестирования программы
Введение
Сложность современного программного обеспечения требует от разработчиков владения наиболее перспективными технологиями его создания. Одно из таких технологий на настоящий момент является объектно-ориентированное программирование (ООП). Применение ООП позволяет разрабатывать программное обеспечение повышенной сложности за счет улучшения его технологичности (лучших механизмов разделения данных, увеличения повторяемости кодов, использование стандартизованных интерфейсов пользователя и т.д.). Вместо того, чтобы рассматривать программу как набор последовательно выполняемых инструкций, в ООП программа представляется в виде совокупности объектов, обладающих сходными свойствами и набором действий, которые можно с ними производить.
Целью работы является закрепление навыков проектирования и разработки классов; разработка абстрактного типа данных (класса), характеризующего ветровой режим; разработка программы, демонстрирующей применение разработанного класса.
В первой главе приводится теоретический материал.
Во второй главе рассмотрена предметная область программирования - характеристика ветрового режима и изложены этапы проектирования класса wind, описаны классы визуальных компонентов стандартной библиотеки, использованные в ходе проектирования интерфейса пользователя.
В третьей главе приводится руководство пользователя.
Четвертая глава содержит результаты тестирования и работы программы.
Приложение содержит программный код и рисунки, с изображением окон написанной программы.
1. Теоретические аспекты объектно-ориентированного программирования
1.1 Основные понятия объектно-ориентированного программирования
Использование технологии ООП заключается в разработке отдельных, не связанных между собой классов и использовании их как необходимых программисту базовых типов данных, отсутствующих в языке. При этом общая структура программы остается традиционной. ("от функции к функции").
Объектно-ориентированное программирование (ООП) - это совокупность понятий (класс, объект, инкапсуляция, полиморфизм, наследование), приемов их использования при проектировании программ, а Си++ - инструмент этой технологии.
Строгое следование технологии ООП предполагает, что любая функция в программе представляет собой метод для объекта некоторого класса. Это не означает, что нужно вводить в программу какие попало классы ради того, чтобы написать необходимые для работы функции. Наоборот, класс должен формироваться в программе естественным образом, как только в ней возникает необходимость описания новых физических предметов или абстрактных понятий (объектов программирования). С другой стороны, каждый новый шаг в разработке алгоритма также должен представлять собой разработку нового класса на основе уже существующих. В конце концов вся программа в таком виде представляет собой объект некоторого класса с единственным методом run (выполнить). Именно этот переход (а не понятия класса и объекта, как таковые) создает психологический барьер перед программистом, осваивающим технологию ООП.
Программирование "от класса к классу" включает в себя ряд новых понятий. Прежде всего, это - инкапсуляция данных, то есть логическое связывание данных с конкретной операцией. Инкапсуляция данных означает, что данные являются не глобальными - доступными всей программе, а локальными - доступными только малой ее части. Инкапсуляция автоматически подразумевает защиту данных. Для этого в структуре class используется спецификатор раздела private, содержащий данные и методы, доступные только для самого класса. Если данные и методы содержатся в разделе public, они доступны извне класса. Раздел protected содержит данные и методы, доступные из класса и любого его производного класса. Наличие последних позволяет говорить об иерархии классов, где есть классы - родители - шаблоны для создания классов - потомков. Объекты, полученные из описания класса, называют экземплярами этого класса.
Вторым по значимости понятием является наследование. Новый, или производный класс может быть определен на основе уже имеющегося, или базового. При этом новый класс сохраняет все свойства старого: данные объекта базового класса включаются в данные объекта производного, а методы базового класса могут быть вызваны для объекта производного класса, причем они будут выполняться над данными включенного в него объекта базового класса. Иначе говоря, новый класс наследует как данные старого класса, так и методы их обработки. Если объект наследует свои свойства от одного родителя, то говорят об одиночном наследовании. Если же объект наследует атрибуты от нескольких базовых классов, то говорят о множественном наследовании. Простой пример наследования - определение структуры, отдельный член которой является ранее определенной структурой.
Третьим по значимости понятием является полиморфизм. Он основывается на возможности включения в данные объекта также и информации о методах их обработки (в виде указателей на функции). Принципиально важно, что такой объект становится "самодостаточным". Будучи доступным в некоторой точке программы, даже при отсутствии полной информации о его типе, он всегда может корректно вызвать свойственные ему методы. Полиморфной называется функция, независимо определенная в каждом из группы производных классов и имеющая в них общее имя. Полиморфная функция обладает тем свойством, что при отсутствии полной информации о том, объект какого из производных классов в данный момент обрабатывается, она тем не менее корректно вызывается в том виде, к каком она была определена для данного конкретного класса. Практический смысл полиморфизма заключается в том, что он позволяет посылать общее сообщение о сборе данных любому классу, причем и родительский класс, и классы-потомки ответят на сообщение соответствующим образом, поскольку производные классы содержат дополнительную информацию.
1.2 Описание класса
Класс является абстрактным типом данных, определяемым пользователем, и представляет собой модель реального объекта в виде данных и функций для работы с ними.
Данные класса называют полями, а функции класса - методами. Поля и методы называют элементами класса. Описание класса в первом приближении выглядит так:
сlass <имя>
{ [private:]
// описание скрытых элементов
Public:
// описание доступных элементов
}; // описание заканчивается точкой с запятой
Спецификаторы доступа private и public управляют видимостью элементов класса. Элементы, описанные после служебного слова private, видимы только внутри класса. Этот вид доступа принят в классе по умолчанию. Интерфейс класса описывается после спецификатора public. Действие любого спецификатора распространяется до следующего спецификатора или до конца класса. Можно задавать несколько секций private и public, порядок их следования значения не имеет.
Поля класса могут:
иметь любой тип, кроме типа этого же класса (но могут быть указателями или ссылками на этот класс);
быть описаны с модификатором const, при этом они инициализируются только один раз и не могут изменяться;
быть описаны с модификатором static.
Классы могут быть глобальными (объявленными вне любого блока) и локальными (объявленные внутри блока, например функции или другого класса).
Ниже приведены некоторые особенности локального класса:
внутри локального класса можно использовать типы, статические (static) и внешние (extern) переменные, внешние функции и элементы перечислений из области, в которой он описан; запрещается использовать автоматические переменные из этой области;
локальный класс не может иметь статических элементов;
методы этого класса могут быть описаны только внутри класса;
если один класс вложен в другой класс, они не имеют каких либо особых прав доступа к элементам друг друга и могут обращаться к ним только по общим правилам.
В качестве примера создадим класс, моделирующий комплексные числа, записываемые в виде а + b i, где а-действительная часть, а b-мнимая.
class Complex // комплексные числа
{
private: int a;
int ib;
public:
void setcomplex (int x, int y) // установка значений поля
{a = x; ib=y; }
void getcomplex () // ввод полей с клавиатуры
{cout<<”\n Введите действительную часть"; cin>>а;
cout<<”\n Введите мнимую часть"; cin>>ib;
}
int get_a () {return a; }
int get_ib () {return ib; }
void show () const
{ cout<<a<<" + "<<ib<<"i"; } // вывод полей на экран
};
В этом классе два скрытых поля a и ib, получить значения которых из вне можно с помощью методов get_a () и get_ib ().
1.3 Описание объектов
Конкретные переменные типа "класс" называются экземплярами класса, или объектами. Время жизни и видимость объектов зависит от вида и места их описания и подчиняется общим правилам C++.
Complex z1; // объект класса Complex с параметрами по умолчанию
Complex z2 (12,14); // объект с явной инициализацией
Complex array_of_complex [100] ; // массив объектов с параметрами по умолчанию
Complex*z = new Complex (10); // динамический объект
Complex &z3 = z1; // ссылка на объект
При создании каждого объекта выделяется память, достаточная для хранения всех его полей, и автоматически вызывается конструктор, выполняющий их инициализацию. Методы класса не тиражируются. При выходе объекта из области действия он уничтожается, при этом автоматически вызывается деструктор.
Доступ к элементам объекта аналогичен доступу к полям структуры. Для этого используется операция точка () при обращении к элементу через имя объекта и операция - > при обращении через указатель, например:
int n = z1. get_a ();
cout<<z->get_ib ();
Обратиться таким образом можно только к элементам со спецификатором public. Получить или изменит значения элементов со спецификатором private можно только через обращение к соответствующим методам.
Можно создать константный объект, значения полей которого изменять запрещается. К нему должны применяться только константные методы:
Class Complex
{
…
int get_a () const {return a; }
…
};
…
const Complex z (0,0); // константный объект
cout<<z. get_a ();
Константный метод:
Объявляется с ключевым словом const после списка параметров;
Не может изменять значений полей класса;
Может вызывать только константные методы;
Может вызываться для любых (не только константных) объектов.
1.4 Конструкторы
Конструктор предназначен для инициализации объекта и вызывается автоматически при его создании. Ниже перечислены основные свойства конструкторов.
Конструктор не возвращает значение, даже типа void. Нельзя получить указатель на конструктор.
Класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации (при этом используется механизм перегрузки).
Конструктор, вызываемый без параметров, называется конструктором по умолчанию.
Параметры конструктора могут иметь любой тип, кроме этого же класса. Можно задавать значения параметров по умолчанию. Их может содержать только один из конструкторов.
Если программист не указал ни одного конструктора, компилятор создает его автоматически. Такой конструктор вызывает конструкторы по умолчанию для полей класса и конструкторы по умолчанию базовых классов. В случае, когда класс содержит константы или ссылки, при попытке создания объекта класса будет выдана ошибка, поскольку их необходимо инициализировать конкретными значениями, а конструктор по умолчанию этого делать не умеет.
Конструкторы не наследуются.
Конструкторы нельзя описывать с модификаторами const, virtual и static.
Конструкторы глобальных объектов вызываются до вызова функции main.
Локальные объекты создаются, как только становится активной область их действия.
Конструктор запускается и при создании временного объекта.
Конструктор вызывается, если в программе встретилась какая-либо из синтаксических конструкций:
имя класса имя_объекта [ (список параметров)] ;
// список параметров не должен быть пустым
имя_класса (список параметров);
// создается объект без имени (список может быть пустым)
имя класса имя_объекта = выражение;
// создается объект без имени и копируется
Примеры:
Complex z1 (10,11), z2;
Complex z = Complex (100, 200);
В первом операторе создаются два объекта. Значения не указанных параметров устанавливаются по умолчанию.
Во втором операторе создается безымянный объект, выделяется память под объект z, в которую копируется безымянный объект.
В качестве примера класса с несколькими конструкторами усовершенствуем класс Complex.
class Complex
{
private: int a;
int ib;
public: Complex (): a (0), ib (0) // конструктор без аргументов
{}
Complex (int za, int zib): a (za), ib (zib) // конструктор с двумя аргументами
{}
void show () const // вывод комплексного числа на экран
{ cout<<a<<" + "<<ib<<"i"; } };
2. Предложения по решению поставленной задачи
2.1 Предметная область программирования. Ветровой режим
Основными характеристиками, описывающими ветровой режим являются скорость (V км/час) и направление (0˚<dd<360˚).
Форма следующая: dd-V.
Например, скорость ветра равна 50 км/ч и направление 120˚ должны быть записаны как 120 град. - 50 км/ч.
2.2 Атрибуты и методы класса. UML-диаграмма
Согласно условию задачи, необходимо создать класс wind, содержащий два поля типа int (направление и скорость ветра соответственно), константные методы вывода значений характеристик ветра в формате (dd-V), а также каждой характеристики в отдельности и метод, позволяющий вычислить значения составляющих скорости. Инициализация объекта должна осуществляться конструкторами: по умолчанию (присваивает полям нулевые значения), с двумя параметрами.
Ключевым принципом ООП является инкапсуляция и возможность сокрытия данных. Т.е. данные заключены внутри класса и защищены от несанкционированного доступа. Статус доступа определяется ключевыми словами: public (общедоступный), private (закрытый), protected - (защищенный). По умолчанию элементы класса имеют закрытый статус доступа.
Если методы класса определены внутри класса, то они являются встраиваемыми. Методы класса могут быть лишь объявлены внутри класса, а определены вне его.
На рисунке 2 представлена UML-диаграмма проектируемого класса wind.
Рисунок 1 - UML-диаграмма класса wind
Чтобы приступить к написанию класса необходимо ознакомиться с окном редактора кода C++ Builder. Редактор кода в C++ Builder при просмотре программного модуля имеет три страницы, закладки которых вы можете видеть в нижней части окна. Две из них отображают коды файла реализации (kursOOP1. cpp) и заголовочного файла (kursOOP1. h). Страница Diagram позволяет строить диаграммы, иллюстрирующие взаимоотношения компонентов в приложении. В заголовке окна редактора кода отображается имя файла реализауции того модуля, с текстом которого вы работаете. Закладки в верхней части окна позволяют переключаться с одного модуля на другой, если в вашем проекте несколько модулей. Если в какой-то из открытых модулей вам больше не нужен, вы можете закрыть его страницы, выбрав в контекстном меню команду ClosePage. Вы можете также открыть дополнительное окно редактора кода и одновременно работать с несколькими модулями или с разными фрагментами одного модуля. В нижней части окна вы можете увидеть типичную для текстовых редакторов строку состояния. В самой левой ее части находится индикатор строки и колонки. Правее расположен индикатор модификации, который словом Modified показывает, что код, который вы видите в окне, изменен и не совпадает с тем, который хранится на диске. В окно редактора также встроена контекстная справка, чтобы ее получить, достаточно установить курсор на интересующее вас слово и нажать клавишу F1.
Рассмотрим подробнее компоненты разрабатываемого класса.
Поля:
Поле dd типа int. Осуществляет хранение значений направления (0˚<dd<360˚).
Поле V типа int. Содержит значение модуля скорости ветра (V км/час).
Данные поля имеют модификатор доступа private, следовательно, являются скрытыми.
Конструкторы и методы:
Конструктор wind (). Осуществляет инициализацию полей данного класса нулями.
Конструктор wind (int dd1, int V1). Инициализирует поля класса двумя параметрами соответственно.
Метод ShowWind. Является функцией типа String, возвращающей строку, содержащую значения полей dd и V соответственно, имеющую вид: dd град. - V км/ч" (значения полей dd и V предварительно переводятся в тип String).
Метод ShowDirect. Является функцией типа int, возвращающей значение поля dd (направление).
Метод ShowSpeed (). Является функцией типа int, возвращающей значение поля V (скорость).
Метод Components. Является функцией типа void. Осуществляет вычисление составляющих скорости u и v. Содержит параметры: w (тип wind) - переменная, по значениям полей которой будет осуществляться вычисление характеристик, v (ссылка на тип float) - возвращает значение составляющей v, u (ссылка на тип float) - возвращает значение составляющей u. Вышеперечисленные функции имеют модификатор доступа public, т.е. являются общедоступными.
2.3 Описание использованных компонентов библиотеки VCL
Компонент StringGrid.
Представляет собой таблицу, содержащую строки. Данные таблицы могут быть только для чтения или редактируемыми. Таблица может иметь полосы прокрутки, причем заданное число первых строк и столбцов может быть зафиксированным и не прокручиваться. Таким образом, можно задать заголовки столбцов и строк, постоянно присутствующие в окне компонента. Каждой ячейке таблицы может быть поставлен в соответствие некоторый объект.
Компонент StringGrid предназначен в первую очередь для отображения таблиц текстовой информации.
Основные свойства:
System:: AnsiString Cells [int ACol] [int ARow] - строка, содержащаяся в ячейке с индексами столбца и строки ACol и ARow.
Classes:: TString*Cols [int Index] - список строк и связанных с ними объектов, содержащихся в столбце с индексом Index.
Classes:: TStrings*Rows [int Index] - список строк и связанных с ними объектов, содержащихся в строке с индексом Index.
System:: TObject*Objects [int ACol] [int ARow] - объект, связанный со строкой, содержащейся в ячейке с индексами столбца и строки ACol и ARow.
ColCount - количество колонок таблицы.
RowCount - количество строк таблицы.
FixedCols - количество зафиксированных слева колонок таблицы. Зафиксированные колонки выделяются цветом и при горизонтальной прокрутке таблицы остаются на месте.
FixedRows - количество зафиксированных сверху строк таблицы. Зафиксированные строки выделяются цветом и при вертикальной прокрутке таблицы остаются на месте.
Options. goEditing - признак допустимости редактирования содержимого ячеек таблицы. True - редактирование разрешено, False - запрещено.
Options. goTab - оазрешает (True) или запрещает (False) использование клавиши <Таb> для перемещения курсора в следующую ячейку таблицы.
Options. GoAlways-ShowEditor - признак нахождения компонента в режиме редактирования. Если значение свойства False, то для того, чтобы в ячейке появился курсор, надо начать набирать текст, нажать клавишу <F2> или сделать щелчок мышью.
DefaultColWidth - ширину колонок таблицы.
DefaultRowHeight - высоту строк таблицы.
GridLineWidth - ширину линий, ограничивающих ячейки таблицы.
Left - расстояние от левой границы поля таблицы до левой границы форм.
Top - расстояние от верхней границы поля таблицы до верхней границы формы.
Height - высоту поля таблицы.
Width - ширину поля таблицы.
Font - шрифт, используемый для отображения содержимого ячеек таблиц.
ParentFont - признак наследования характеристик шрифта формы.
Все вышеперечисленные свойства доступны во время выполнения. Задавать тексты можно программно или по отдельным ячейкам, или сразу по столбцам и строкам с помощью методов класса TString.
Компонент Edit производит отображение, ввод и редактирование однострочных текстов. Вводимый и выводимый текст содержится в свойстве Text типа AnsiString. Это свойство можно устанавливать в процессе проектирования или задавать программно.
Компонент Label Отображение текста, не изменяемого пользователем. Никакого оформления, кроме цвета текста. Это свойство можно устанавливать в процессе проектирования или задавать программно. Основное свойство - Caption.
2.4 Проектирование пользовательского интерфейса. Объектная декомпозиция
Для создания Windows-приложения в среде C++ Builder 6.0 необходимо зайти в меню File, выбрать сроку New, в появившимся списке выбрать графу Application. После совершения данных действий перед пользователем появляется Windows-форма, на которую будут помещаться прочие компоненты.
В верхней части экрана можно увидеть панель, на которой расположены компоненты библиотеки VCL. Щелкнем по странице Standart, выберем там компонент GroupBox. Данный компонент является частью дизайна Windows-формы. В нижнем левом углу экрана можно увидеть инспектор объектов. Инспектор объектов обеспечивает простой и удобный интерфейс для изменения свойств объектов C++ Builder и управления событиями, на которые реагирует объект. Окно инспектора объектов имеет две страницы. Выше их имеется выпадающий список всех компонентов, размещенных на форме. В нем можно выбрать тот компонент, свойства и события которого вас интересуют. Страница свойств (Properties) инспектора объектов показывает свойства того объекта, который в данный момент выделен вами. Выделим объект GroupBox1, в появившимся перечне свойств данного объекта выберем свойство Caption (надпись в верхнем правом углу объекта), присвоим ему необходимое значение.
Далее поместим на форму объект Button (кнопка), в свойстве Caption напишем "Заполнить таблицу".
Выберем объект StringGrid. В его свойстве ColCount (количество столбцов) укажем значение 2, в свойстве RowCount (количество строк) укажем 10, а свойству FixedRows (фиксированные строки) присвоим значение 2. Далее поместим на форму по три объекта Edit и Label.
На рисунке 2 показана схема формы Form1.
Рисунок 2 - схема формы Form1
Страница событий (Events) составляет вторую часть инспектора объектов. На ней указаны все события, на которые может реагировать выбранный объект. Если необходимо выполнить какие-то действия в момент создания формы, требуется выделить событие OnCreate. Рядом с именем этого события откроется окно с выпадающим списком. Если вы уже написали в своем приложении какие-то обработчики событий и хотите при при данном событии использовать один из них, вы можете выбрать необходимый обработчик из выпадающего списка. Если же вам надо написать новый обработчик, то сделайте двойной щелчок на пустом окне списка. Вы попадете в окно редактора кода, в котором увидите текст:
void __fastcall TForm1:: FormCreate (TObject *Sender)
{ }
Курсор будет расположен в пустой строке между строками с открывающейся и закрывающимися фигурными скобками. Увиденный вами код - это заготовка обработчика события, которую автоматически сделал C++ Builder. Вам остается только в промежутке между скобками “{“ и “}” написать необходимые операторы.
Рассмотрим обработчики событий, представленные в программе:
FormCreate. Событие OnCreate означает, что указанные действия будут совершаться при создании формы Form1. Совершаемые при этом действия: при помощи знака косвенной адресации обратщаемся к свойству Cells ячеек первого и второго столбцов первой строки объекта stringGrid1 (заголовки столбцов) и присваиваем им значения "Направление в град." и "Скорость", свойству RowCount присваиваем значение константы n=10, при помощи двух циклов for обращаемся к каждой ячейке и удаляем из нее информацию.
Button1Click. Событие OnClick подразумевает щелчок мышью по данному объекту. Совершаемые при этом действия: в теле цикла for совершаем заполнение массива array элементами типа wind (полям i-того элемента присваиваем при помощи конструктора случайные значения), записываем значения полей данного элемента в ячейки таблицы StringGrid1 (направление в 0-ой столбец при помощи метода ShowDirect, скорость в 1-ый при помощи метода ShowSpeed).
StringGrid1SelectCell. Событие OnSelectCell подразумевает щелчок мышью по ячейке с номером столбца - ACol, строки - ARow. Совершаемые при этом действия: строке Edit1. Text присваиваем значение элемента под номером ARow-1 при помощи метода ShowWind (возвращает значение переменной типа wind в виде строки типа String), вычисляем при помощи метода Components значения составляющих скорости, выводим их значения (переведенные в тип String при помощи функции FloatToString) на экран с помощью объектов Edit2 и Edit3.
Вышеуказанная схема показывает алгоритм взаимодействия визуальных компонентов формы при условии совершения пользователем определенных действий. При щелчке мышью по кнопке "Заполнить массив" происходит ввод значений элементов массива array в ячейки таблицы StringGrit1. При выделении какой-либо ячейки данной таблицы производится вывод значения соответствующего элемента массива на экран при помощи объекта Edit1 и значений составляющих скорости при помощи объектов Edit2 и Edit3.
3. Описание ПО
3.1 Руководство пользователя
Данная программа предназначена для демонстрации использования класса wind, характеризующего ветровой режим.
Выходные данные - массив array, значения составляющих v и u.
Системные требования: Pentium 300, 128 Мб RAM.
Запустите файл ProjectOOP. exe. Перед пользователем появится окно программы (см. рисунок 1 приложения 2), состоящее из таблицы, кнопки "Заполнить таблицу" и трех строк - "Характеристики ветра", "Составляющая скорости v", "Составляющая скорости u". Чтобы заполнить таблицу случайными значениями нажмите кнопку "Заполнить таблицу". Таблица выведет на экран значение угла, характеризующего направление ветра (первый столбец таблицы) и скорость ветра (второй столбец) - значения элементов массива переменных типа wind (см. рисунок 2 приложения 2). При выделении какой-либо ячейки таблицы в строке "Характеристики ветра" будет выведено значение характеристик ветра в виде dd-V, строки "Составляющая скорости v" и "Составляющая скорости u" выведут соответствующие значения составляющих скорости для данного элемента массива (см. рисунок 3 приложения 2).
3.2 Результат тестирования программы
После запуска файла ProjectOOP. exe на экране появилось окно программы (см. рисунок 1 приложения 2). После нажатия кнопки "Заполнить массив" при помощи электронной таблицы StringGrid были выведены значения элементов массива: поле dd (направление ветра) - в левой колонке, поле V (скорость) - в правой (см. рисунок 2 приложения 2). При выделении какой-либо ячейки таблицы в строке "Характеристики ветра" выводилось значение соответствующей пременной в виде dd-V. В строках "Составляющая скорости u" и "Составляющая скорости v" выводились соответствующие значения составляющих скорости (см. рисунок 3 приложения 2). Программа выводит значения элементов массива переменных класса wind на экран, вычисляет значения составляющих скорости для каждого элемента, следовательно, она работает правильно.
Заключение
Проектирование и разработка классов является основой построения сложных программных комплексов. Навыки, приобретенные мною в ходе выполнения курсовой работы помогут в дальнейшем при выполнении курсовых и дипломного проекта.
В результате работы получены следующие результаты:
спроектирован класс wind, характеризующий ветровой режим,
построена UML - диаграмма класса,
написан программный модуль на языке программирования C++ в среде программирования C++Buiilder 6/0 демонстрирующий работу с классом wind,
разработано руководство по применению программы.
Приложения
Приложение 1
Текст программы
Код заголовочного файла (kursOOP1. h):
// ---------------------------------------------------------------------------
#ifndef kursOOP1H
#define kursOOP1H
// ---------------------------------------------------------------------------
#include <Classes. hpp>
#include <Controls. hpp>
#include <StdCtrls. hpp>
#include <Forms. hpp>
#include <Grids. hpp>
// ---------------------------------------------------------------------------
class TForm1: public TForm
{
__published: // IDE-managed Components
TStringGrid *StringGrid1;
TGroupBox *GroupBox1;
TButton *Button1;
TEdit *Edit1;
TLabel *Label1;
TEdit *Edit2;
TLabel *Label2;
TEdit *Edit3;
TLabel *Label3;
void __fastcall FormCreate (TObject *Sender);
void __fastcall Button1Click (TObject *Sender);
void __fastcall StringGrid1SelectCell (TObject *Sender, int ACol,
int ARow, bool &CanSelect);
private: // User declarations
public: // User declarations
__fastcall TForm1 (TComponent* Owner);
};
// ---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
// ---------------------------------------------------------------------------
#endif
Код файла реализации (kursOOP1. cpp):
// ---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
#include "kursOOP1. h"
#include <Math. h>
#include <string>
#include <stdlib. h>
#include <dstring. h>
// ---------------------------------------------------------------------------
#pragma package (smart_init)
#pragma resource "*. dfm"
class wind
{
private: int dd;
int V;
public:
wind (): dd (0),V (0) {};
wind (int dd1, int V1): dd (dd1),V (V1) {};
String ShowWind () const
{
return IntToStr (dd) +" град. - "+IntToStr (V) +" км/ч";
}
int ShowDirect () const
{return dd;
}
int ShowSpeed () const
{return V;
}
void Components (wind w,float&v,float&u) const
{v=V*sin (dd);
u=V*cos (dd); }
};
TForm1 *Form1;
const n=10;
wind array [n] ; float v,u;
// ---------------------------------------------------------------------------
__fastcall TForm1:: TForm1 (TComponent* Owner)
: TForm (Owner)
{
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormCreate (TObject *Sender)
{
StringGrid1->Cells [0] [0] ="Направление в град. ";
StringGrid1->Cells [1] [0] ="Скорость";
StringGrid1->RowCount=n;
for (int j=0; j<2; j++)
{for (int i=1; i<n; i++)
{StringGrid1->Cells [j] [i] =""; }}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button1Click (TObject *Sender)
{
for (int i=0; i<n; i++)
{array [i] =wind (random (360),random (250));
StringGrid1->Cells [0] [i+1] =array [i]. ShowDirect ();
StringGrid1->Cells [1] [i+1] =array [i]. ShowSpeed (); }
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: StringGrid1SelectCell (TObject *Sender, int ACol,
int ARow, bool &CanSelect)
{
Edit1->Text=array [ARow-1]. ShowWind ();
array [ARow-1].components (array [ARow-1],v,u);
Edit2->Text=FloatToStr (v);
Edit3->Text=FloatToStr (u);
}
// ---------------------------------------------------------------------------
Приложение 2
Результаты тестирования
Рис.1 - окно программы
Рис.2 - вывод значений элементов массива на экран при помощи таблицы StringGrid1
Рис.3 - вывод значений характеристик ветра в виде dd-V и составляющих скорости