МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
Державна освітня установа
Вищої професійної освіти
"Кубанський державний технологічний університет"
(КубГТУ)
Армавірський механіко-технологічний інститут
Кафедра внутрішньозаводського електрообладнання та автоматики
ПОЯСНЮВАЛЬНА ЗАПИСКА
до курсового проекту
з дисципліни Об'єктно-орієнтоване програмування
на тему "Проектування і розробка абстрактних типів даних засобами мови програмування 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 Основні поняття об'єктно-орієнтованого програмування
1.2 Опис класу
1.3 Опис об'єктів
1.4 Конструктори
2. Пропозиції щодо вирішення поставленого завдання
2.1 Предметна область програмування. Вітровий режим
2.2 Атрибути і методи класу. UML-діаграма
2.3 Опис використаних компонентів бібліотеки VCL
2.4 Проектування користувальницького інтерфейсу. Об'єктна декомпозиція
3. Опис ПЗ
3.1 Керівництво користувача
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 z 1; / / об'єкт класу Complex з параметрами за замовчуванням
Complex z 2 (12,14); / / об'єкт з явною ініціалізацією
Complex array _ of _ complex [100]; / / масив об'єктів з параметрами за замовчуванням
Complex * z = new Complex (10); / / динамічний об'єкт
Complex & z 3 = z 1; / / посилання на об'єкт
При створенні кожного об'єкта виділяється пам'ять, достатня для зберігання всіх його полів, і автоматично викликається конструктор, виконує їх ініціалізацію. Методи класу не тиражуються. При виході об'єкта з області дії він знищується, при цьому автоматично викликається деструктор.
Доступ до елементів об'єкта аналогічний доступу до полів структури. Для цього використовується операція точка () при зверненні до елемента через ім'я об'єкта і операція -> при зверненні через вказівник, наприклад:
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 при перегляді програмного модуля має три сторінки, закладки яких ви можете бачити в нижній частині вікна. Дві з них відображають коди файлу реалізації (kursOOP 1. Cpp) і заголовного файлу (kursOOP 1. H). Сторінка Diagram дозволяє будувати діаграми, що ілюструють взаємовідносини компонентів у додатку. У заголовку вікна редактора коду відображається ім'я файлу реалізауціі того модуля, з текстом якого ви працюєте. Дані у верхній частині вікна дозволяють перемикатися з одного модуля на інший, якщо у вашому проекті кілька модулів. Якщо в якійсь з відкритих модулів вам більше не потрібний, ви можете закрити його сторінки, вибравши в контекстному меню команду ClosePage. Ви можете також відкрити додаткове вікно редактора коду й одночасно працювати з декількома модулями або з різними фрагментами одного модуля. У нижній частині вікна ви можете побачити типову для текстових редакторів рядок стану. У самій лівій її частині знаходиться індикатор рядка і колонки. Правіше розташований індикатор модифікації, що словом Modified показує, що код, який ви бачите у вікні, змінений і не збігається з тим, який зберігається на диску. У вікно редактора також вбудована контекстна довідка, щоб її отримати, достатньо встановити курсор на цікавить вас слово і натиснути клавішу F 1.
Розглянемо докладніше компоненти розроблюваного класу.
Поля:
Поле 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) інспектори об'єктів показує властивості того об'єкта, який в даний момент виділено вами. Виділимо об'єкт GroupBox 1, у що з'явилися переліку властивостей даного об'єкта виберемо властивість Caption (напис у верхньому правому куті об'єкта), привласнимо йому необхідне значення.
Далі помістимо на форму об'єкт Button (кнопка), у властивості Caption напишемо "Заповнити таблицю".
Виберемо об'єкт StringGrid. У його властивості ColCount (кількість стовпців) вкажемо значення 2, у властивості RowCount (кількість рядків) вкажемо 10, а властивості FixedRows (фіксовані рядки) привласнимо значення 2. Далі помістимо на форму по три об'єкти Edit і Label.
На малюнку 2 показана схема форми Form 1.
Рисунок 2 - схема форми Form 1
Сторінка подій (Events) становить другу частину інспектора об'єктів. На ній зазначені всі події, на які може реагувати вибраний об'єкт. Якщо необхідно виконати якісь дії в момент створення форми, потрібно виділити подія OnCreate. Поруч з ім'ям цієї події відкриється вікно з списком, що випадає. Якщо ви вже написали в своєму додатку якісь обробники подій і хочете при при даній події використовувати один з них, ви можете вибрати необхідний обробник з випадаючого списку. Якщо ж вам треба написати новий обробник, то зробіть подвійне клацання на порожньому вікні списку. Ви потрапите у вікно редактора коду, в якому побачите текст:
void __fastcall TForm1:: FormCreate (TObject * Sender)
{}
Курсор буде розташований в порожній рядку між рядками з відкривається і закриваються фігурними дужками. Побачений вами код - це заготовка обробника події, яку автоматично зробив C + + Builder. Вам залишається тільки в проміжку між дужками "{" і "}" написати необхідні оператори.
Розглянемо обробники подій, представлені в програмі:
FormCreate. Подія OnCreate означає, що зазначені дії будуть відбуватися при створенні форми Form 1. Здійснюються при цьому дії: за допомогою знака непрямої адресації обратщаемся до властивості Cells осередків першого і другого стовпців першого рядка об'єкта stringGrid 1 (заголовки стовпців) і присвоюємо їм значення "Напрям у град." і "Швидкість", властивості RowCount присвоюємо значення константи n = 10, за допомогою двох циклів for звертаємося до кожному осередку і видаляємо з неї інформацію.
Button 1 Click. Подія OnClick увазі клацання мишею по даному об'єкту. Здійснюються при цьому дії: у тілі циклу for здійснюємо заповнення масиву array елементами типу wind (полях i-того елемента присвоюємо за допомогою конструктора випадкові значення), записуємо значення полів даного елемента в елементи таблиці StringGrid 1 (напрямок в 0-ой стовпець за допомогою методу ShowDirect, швидкість в 1-ий за допомогою методу ShowSpeed).
StringGrid 1 SelectCell. Подія OnSelectCell увазі клацання мишею по клітинці з номером шпальти - ACol, рядки - ARow. Здійснюються при цьому дії: рядку Edit 1. Text присвоюємо значення елементу під номером ARow -1 при допомогою методу ShowWind (повертає значення змінної типу wind у вигляді рядка типу String), обчислюємо за допомогою методу Components значення складових швидкості, виводимо їх значення (переведені в тип String за допомогою функції FloatToString) на екран за допомогою об'єктів Edit 2 і Edit 3.
Вищевказана схема показує алгоритм взаємодії візуальних компонентів форми за умови здійснення користувачем певних дій. При клацанні мишею по кнопці "Заповнити масив" відбувається введення значень елементів масиву array в елементи таблиці StringGrit 1. При виділенні якої-небудь осередки даної таблиці проводиться вивід значення відповідного елемента масиву на екран за допомогою об'єкта Edit 1 і значень складових швидкості за допомогою об'єктів Edit 2 і Edit 3.
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
Текст програми
Код заголовного файлу (kursOOP 1. 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 - висновок значень елементів масиву на екран за допомогою таблиці StringGrid 1
Рис.3 - висновок значень характеристик вітру у вигляді dd - V і складових швидкості