Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Створення списків сталих об’єктів
Інформація про навчальний заклад
ВУЗ:
Київський Національний університет будівництва і архітектури
Інститут:
Не вказано
Факультет:
ЗІ
Кафедра:
Не вказано
Інформація про роботу
Рік:
2013
Тип роботи:
Курсова робота
Предмет:
Об’єктно-орієнтоване програмування
Частина тексту файла (без зображень, графіків і формул):
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
КИЇВСЬКИЙ НАЦІОНАЛЬНИЙ УНІВЕРСИТЕТ
БУДІВНИЦТВА І АРХІТЕКТУРИ
Кафедра інформаційних технологій
КУРСОВА РОБОТА
З ДИСЦИПЛІНИ
“Об’єктно-орієнтоване програмування”
за темою: «Створення списків сталих об’єктів»
Виконали студенти ІІ курсу факультету АІТ
спеціальності ІУСТ
_ Самойленко Вікторія Миколаївна _
(прізвище, ім’я, по батькові)
Керівник роботи: Красовська Ганна Валеріївна
Київ – 2013
ЗМІСТ
Теоретична частина……………………………………………………................4
Завдання до курсової роботи……………………………………………………17
UML - діаграма прецедентів…………………………………………………….18
UML – Діаграма класів ………………………………………………………….19
UML - Діаграма компонентів…………………………………………………..20
Дерево функції…………………...………………………………………………21
Опис класів……………………………………………………………………….22
Опис прецедентів……………………………………………………………………….23
Опис програмного інтерфейсу користувача…………………………………..24
Тестовий приклад…………………………………………………………………………..25
Текст програми
Unit1.cpp………………………………………………………………………….26
Unit1.h……………………………………………………………………………28
Список використаної літератури……………………………………………......32
Теоретична частина
Перевантаження операцій потокового уведення/виведення.
Файлове уведення/виведення. Управління потоковим уведенням/виведенням.
Частиною стандартної бібліотеки C + + є бібліотека iostream - об'єктно -орієнтована ієрархія класів , де використовується і множинне , і віртуальне успадкування . У ній реалізована підтримка для файлового введення / виведення даних вбудованих типів . Крім того , розробники класів можуть розширювати цю бібліотеку для зчитування і запису нових типів даних.
Для використання бібліотеки iostream в програмі необхідно включити заголовний файл
# include <iostream>
Операції введення / виводу виконуються за допомогою класів istream ( потоковий введення) і ostream ( потоковий виведення ) . Третій клас , iostream , є похідним від них і підтримує двонаправлене введення / виведення . Для зручності в бібліотеці визначено три стандартних об'єкта - потоку :
cin - об'єкт класу istream , який відповідає стандартному вводу . У загальному випадку він дозволяє читати дані з терміналу користувача;
cout - об'єкт класу ostream , який відповідає стандартному виведенню . У загальному випадку він дозволяє виводити дані на термінал користувача;
cerr - об'єкт класу ostream , який відповідає стандартному виведенню помилок. У цей потік ми направляємо повідомлення про помилки програми .
Висновок здійснюється , як правило , за допомогою перевизначенного оператора зсуву вліво ( << ) , а введення - за допомогою оператора зсуву вправо ( >> ) :
Крім читання з терміналу і запису на нього , бібліотека iostream підтримує читання і запис у файл . Для цього призначені наступні класи:
ifstream , похідний від istream , пов'язує введення програми з файлом ;
ofstream , похідний від ostream , пов'язує виведення програми з файлом ;
fstream , похідний від iostream , пов'язує як введення , так і виведення програми з файлом.
Щоб використати частину бібліотеки iostream , пов'язану з файловим введенням / виведенням , необхідно включити в програму заголовний файл
# include <fstream>
(Файл fstream вже включає iostream , так що включати обидва файли необов'язково. ) Файловий ввід / вивід підтримується тими ж операторами :
# include <fstream>
# include <string>
# include <vector>
# include <algorithm>
int main ( )
{
string ifile ;
cout < " Введіть ім'я файлу для сортування :";
cin >> ifile ;
/ / Сконструювати об'єкт класу ifstream для введення з файлу
ifstream infile ( ifile.c_str ( )) ;
if (! infile ) {
cerr < " помилка: не можу відкрити вхідний файл : "
< Ifile < endl ;
return -1 ;
}
string ofile = ifile + ". sort " ;
/ / Сконструювати об'єкт класу ofstream для виводу у файл
ofstream outfile ( ofile.c_str ( )) ;
if (! outfile ) {
cerr << " помилка: не можу відкрити вихідний файл : "
<< Ofile << endl ;
return -2 ;
}
string buffer ;
vector < string , allocator > text ;
int cnt = 1 ;
while ( infile >> buffer ) {
text.push_back ( buffer ) ;
cout << buffer << ( cnt + + % 8 ? "" : "\ n " ) ;
}
sort ( text.begin ( ) , text.end ( )) ;
/ / Виводимо безліч відсортованих слів в файл
vector <string > :: iterator iter = text.begin ();
for ( cnt = 1 ; iter ! = text.end (); + + iter , + + cnt )
outfile << * iter
<< ( Cnt % 8 ? "" : "\ N " ) ;
return 0 ;
}
Бібліотека iostream підтримує також введення / виведення в область пам'яті , при цьому потік зв'язується з рядком в пам'яті програми . За допомогою потокових операторів введення / виведення ми можемо записувати дані в цей рядок і зчитувати їх з нього. Об'єкт для строкового введення / виводу визначається як екземпляр одного з наступних класів :
istringstream , похідний від istream , читає з рядка ;
ostringstream , похідний від ostream , пише в рядок ;
stringstream , похідний від iostream , виконує як читання , так і запис .
Для використання будь-якого з цих класів у програму потрібно включити заголовний файл # include <sstream>
(Файл sstream вже включає iostream , так що включати обидва файли необов'язково. ) У наступному фрагменті об'єкт класу ostringstream використовується для форматування повідомлення про помилку , яке повертається викликає програмі .
Потоки введення / виведення підтримують два зумовлені типи: char і wchar_t. У цьому розділі ми розповімо тільки про читання і запису в потоки даних типу char . Крім них , у бібліотеці iostream є набір класів і об'єктів для роботи з типом wchar_t . Вони відрізняються від відповідних класів , що використовують тип char , наявністю префікса ' w ' . Так , об'єкт стандартного введення називається wcin , стандартного виводу - wcout , стандартного виводу для помилок - wcerr . Але набір заголовків файлів для char і wchar_t один і той же.
Класи для введення / виведення даних типу wchar_t називаються wostream , wistream , wiostream , для файлового введення / виводу - wofstream , wifstream , wfstream , а для строкового - wostringstream , wistringstream , wstringstream .
Безформатне уведення-виведення
Коли файл відкривається в текстовому режимі, відбувається наступне:
при введенні кожна пара символів '\r' +' \n' (повернення каретки + переклад рядка) перетвориться в символ перекладу рядка ('\n');
при виводі кожен символ перекладу рядка ('\n') перетвориться в пару '\r' +'\n' (повернення каретки + переклад рядка).
Це не завжди зручно. Якщо необхідно використовувати файл виводу для подальшого введення в програму (можливо, іншу), зайві байти інформації ні до чого. З цією метою система введення-виводу надає можливість здійснення безформатного введення-виводу, тобто записи і читання двійкової інформації (інколи говорять - сирих даних). Для здійснення введення-виводу в двійковому режимі потрібно включити прапор ios::binary в параметр open_mode, передаваний конструктору потоку або функції open(). Читання двійкової інформації з файлу здійснюється функцією read(), яка має наступні прототипи:
istream & read(char* s, int n); istream & read(unsigned char* s, int n);
Тут параметр s задає буфер для прочитування даних, а параметр n - число читаних символів.
Запис двійкових даних здійснює функція-член write():
оstream& write(const char * s, int n); оstream& write(const unsigned char * s, int n);
Ця функція отримує n символів з буфера, адреса якого задана параметром s, і вставляє їх в потік виводу. Розглянемо приклад.
#include< iоstream.h > #include< fstream.h > void main() { int x = 255; char str[80]= "Тестування двійкового введення-виводу."; // Відкриваємо файл для виводу в двійковому режимі ofstream ofs("Test.dat"); if (!ofs) { cout << "Файл не відкритий.\n"; return; } ofs.write((char*)&x, sizeof(int)); ofs.write((char*)&str, sizeof(str)); ofs.close(); // Відкриваємо файл для виводу в двійковому режимі ifstream ifs("Test.dat"); if (!ifs) { cout << "Файл не відкритий.\n"; return; } ifs.read((char*)&x, sizeof(int)); ifs.read((char*) str, sizeof(str)); cout << x << '\n' << str << '\n'; }
Часто вживані функції бібліотеки введення / виводу
Окрім вже описаних функцій, бібліотека введення-виведення C++ містить широкий набір різних функцій. Тут ми приведемо лише деякі, що найчастіше вживаються з них. Більшість цих функцій використовуються для безформатного введення-виводу.
Для витягання символу з потоку можна використовувати функцію-член get() потоку istream . Вона має наступні прототипи:
int get(); istream & get(signed char*, int len, char delim= '\n'); istream & get(unsigned char*, int len, char delim= '\n'); istream & get(unsigned char &); istream & get(signed char &); istream & get(streambuf &, char delim= '\n');
Функція get() у першій формі повертає код прочитаного символу або -1, якщо зустрівся кінець файлу введення (ctrl/z).
Наведемо приклад використання функції get ():
#include < iоstream.h > void main(){ char ch; cout << "Введіть число. " << "Для завершення введення натискуйте < ENTER >:"; while (cin.get(ch)){ // Перевірка на код клавіші < ENTER > if (ch = = '\n') break; } return; }
Для вставки символу в потік виводу використовується функція put() з прототипом ostreaiu& put(char ch). Функція get () може також використовуватися для читання рядка символів. В цьому випадку використовуються її варіанти, в яких ця функція витягує з вхідного потоку символи в буфер str, поки не зустрінеться символ-обмежувач delim (за умовчанням - переклад рядка) або не буде прочитано (len-1) символів, або не буде прочитана ознака кінця файлу. Сам символ-обмежувач не витягується з вхідного потоку.
З огляду на те, що функція get() не витягує з вхідного потоку символ-обмежувач, вона використовується рідко. Набагато частіше використовується функція getline(), яка витягує з вхідного потоку символ-обмежувач, але не поміщає його в буфер. Вона має наступні прототипи:
istream & getline (char* str, int len, char delim); istream & getline(char * str, int len);
Тут параметри мають ті ж призначення, що і у функції get().
Функція gcount() (з прототипом int gcount()const;) повертає число символів, що витягують з потоку останньою операцією безформатного введення (тобто функцією get(), getline() або read()).
Розглянемо приклад, в якому використовуються дві останні функції:
#include < iоstream.h > void main(){ char *name; int len = 100; int count = 0; name = new char[len]; cout << "Введіть своє ім'я:"; cin.getline(name, len); count = cin.gcount(); // Зменшуємо значення лічильника на 1, оскільки // getline() не поміщає обмежувач в буфер cout << "\nЧисло прочитаних символів: " << count - 1; }
Для того, щоб пропустити при введенні декілька символів, використовується функція ignore():
istream & ignore(int n = l, int delim = EOF);
Ця функція ігнорує аж до n символів у вхідному потоці. Пропуск символів припиняється, якщо вона зустрічає символ-обмежувач, яким за умовчанням є символ кінця файлу. Символ-обмежувач витягується з вхідного потоку.
Функція рейок(), що має прототип int рейок(), дозволяє "заглянути" у вхідний потік і взнати наступний символ, що вводиться. При цьому сам символ з потоку не витягується.
За допомогою функції putback() (з прототипом istream &putback(char ch);) можна повернути символ ch в потік введення.
При виконанні виводу дані не відразу записуються у файл, а тимчасово зберігаються в пов'язаному з потоком буфері, поки він не заповниться. Функція flush() дозволяє викликати примусовий запис у файл до заповнення буфера.
Вона неявно використовується маніпулятором endl. Цей маніпулятор вставляє в потік символ перекладу рядка і очищає буфер. Таким чином, оператор
cout << endl; эквивалентен наступним:
cout << '\n'; cout.flush();
Функція rdbuf() дозволяє отримати покажчик на пов'язаний з потоком буфер. Ця функція має прототип streambuf * rdbuf() const;
Нарешті, функція setbuf() з прототипом void setbuf(char*buf, int n) дозволяє пов'язати з потоком інший буфер. Тут buf - покажчик на інший буфер довжини n.
Файлове уведення-виведення з використанням потоків
Для здійснення операцій з файлами передбачено три класи: ifstream, ofstream і fstream. Ці класи є похідними, відповідно, від класів istream, оstream і iоstream. Оскільки ці останні класи, у свою чергу, є похідними від класу ios, класи файлових потоків успадковують всі функціональні можливості своїх батьків (переобтяжені операції << і >> для вбудованих типів, функції і прапори форматування, маніпулятори і ін.). Для реалізації файлового введення-виводу потрібно включити в програму заголовний файл fstream.h.
Існує невелика відмінність між використанням зумовлених і файлових потоків. Файловий потік має бути пов'язаний з файлом перш, ніж його можна буде використовувати. З іншого боку, зумовлені потоки можуть використовуватися відразу після запуску програми, навіть в конструкторах статичних класів, які виконуються навіть раніше виклику функції main(). Можна позиціювати файловий потік в довільну позицію у файлі, тоді як для зумовлених потоків це зазвичай не має сенсу.
Для створення файлового потоку ці класи передбачають наступні форми конструктора:
створити потік, не пов'язуючи його з файлом:
ifstream(); ofstream(); fstream();
створити потік, відкрити файл і пов'язати потік з файлом:
ifstream(const char *name, ios::openmode mode = ios::in); ofstream(const char* name, ios::openmode mode=ios::out | ios::trunc); fstream(const char * name, ios::openmode mode = ios::in | ios::out);
Аби відкрити файл для введення або виводу, можна використовувати другу форму потрібного конструктора, наприклад:
fstream fs("FileName.dat");
або спочатку створити потік за допомогою першої форми конструктора, а потім відкрити файл і пов'язати потік з відкритим файлом, викликавши функцію-член open(). Ця функція визначена в кожному з класів потокового введення-виводу і має наступні прототипи:
void ifstream::open(const char *name, ios::openmode mode = ios::in); void ofstream::open (const char * name, ios::openmode mode = ios::out | ios::trunc); void fstream::open (const char * name, ios::openmode mode = ios::in | ios::out);
Тут name - ім'я файлу, mode - режим відкриття файлу. Параметр mode є перерахуванням і може набувати значень, вказаних в таблиці. 11.5.
Таблиця 1. Режими відкриття і їх призначення
Режим відкриття
Призначення
ios::in
Відкрити файл для читання
ios::out
Відкрити файл для запису
ios::ate
Початок виводу встановлюється в кінець файлу
ios::app
Відкрити файл для додавання в кінець
ios::trunc
Усікти файл, тобто видалити його вміст
ios::binary
Двійковий режим операцій
Режими відкриття файлу є бітовими масками, тому можна задавати два або більш за режим, об'єднуючи їх побітовою операцією АБО. У наступному фрагменті коди файл відкривається для виводу за допомогою функції open():
ofstream ofs; ofs.open("FileName.dat");
Звернемо увагу, що за умовчанням режим відкриття файлу відповідає типові файлового потоку. В потоку введення або виводу прапор режиму завжди встановлений неявно. Наприклад, для потоку виводу в режимі додавання файлу можна замість оператора
ofstream ofs("FName.txt", ios::out | ios::app); написать ofstream ofs("FName.txt", ios::app);
Між режимами відкриття файлу ios::ate і ios::app є невелика різниця.
Якщо файл відкривається в режимі додавання, весь вивід у файл здійснюватиметься в позицію, що починається з поточного кінця файлу, безвідносно до операцій позиціювання у файлі. У режимі відкриття ios::ate (від англійського "at end") можна змінити позицію виводу у файл і здійснювати запис, починаючи з її. Для потоків виводу режим відкриття еквівалентний ios::out | ios::trunc, тобто можна опустити режим усікання файлу. Проте для потоків введення-виведення його потрібно вказувати явно. Файли, які відкриваються для виводу, створюються, якщо вони ще не існують.
Якщо відкриття файлу завершилося невдачею, об'єкт, відповідний потоку, повертатиме 0:
if (!ofs){ cout << "Файл не відкрит\n";}
Перевірити успішність відкриття файлу можна також за допомогою функції-члена is_open(), що має наступний прототип:
int is_open() const;
Функція повертає 1, якщо потік удалося пов'язати з відкритим файлом. Наприклад
if (!ofs.is_open()){ cout << "Файл не відкрит\n"; return; }
Якщо при відкритті файлу не вказаний режим ios::binary, файл відкривається в текстовому режимі і після того, як файл успішно відкритий, для виконання операцій введення-виводу можна використовувати операторів витягання і вставки в потік. Для перевірки, чи досягнутий кінець файлу, можна використовувати функцію ios::eof(), що має прототип int eof();
Завершивши операції введення-виводу, необхідно закрити файл, викликавши функцію-член close() з прототипом void close():
ofs.close();
Закриття файлу відбувається автоматично при виході потокового об'єкту з області існування, коли викликається деструкція потоку.
Розглянемо приклад, що демонструє файлове уведення-виведення з використанням потоків:
#include < iоstream.h > #include < fstream.h > void main(){ int n = 50; // Відкриваємо файл для виводу ofstream ofs("Test.txt"); if (!ofs) {cout << "Файл не відкритий.\n"; return;} ofs << "Hello!\n" << n; // Закриваємо файл ofs.close(); // відкриваємо той же файл для введення ifstream file("Test.txt"); if (!file) {cout << "Файл не відкритий.\n"; return;} char str[80]; file >> str >> n; cout << str << " " << n << endl; // Закриваємо файл file.close(); }
Завдання до курсової роботи
Визначити клас для шахової фігури- ферзь.
Основні класи:
1) шахова фігура ферзь (колір, координата по вертикалі, координата по горизонталі)
2) шахова фігура ферзь зі зміненими координатами.
Основні функції:
1) Додавання фігури
2) Переміщення фігури
UML - діаграма прецедентів
користувач
UML – Діаграма класів
Figure
int x,color; AnsiString nameF, y;
Figure()
void set_x(int x_n)
int get_x()
void set_y(AnsiString y_n)
AnsiString get_y()
void set_color_nameF(int color_n)
i nt get_color()
virtual bool move()=0
Ferz
int x1; AnsiString y1 ;
void set_x1(int x1_n)
int get_x1()
void set_y1(AnsiString y1_n)
AnsiString get_y1()
bool move()
void view(TImage *image)
void image(TImage *Image)
TList
Capacity()
Count()
Items[]
Add()
Delete()
Pack()
Move()
Exchange()
TList
__fastcall ~FerzList()
void DelFerz(int i)
void AddFerz(int s_x, AnsiString s_y, int s_x1, AnsiString s_y1, int s_color)
Ferz* GetFerz(int i)
void FindFerz(AnsiString s_nameF, int s_color)
static int __fastcall SortListByInt(void * Item1, void * Item2)
void SortByInt()
UML - Діаграма компонентів
Дерево функцій
Створюється класс Ферзь
Обирається колір
Встановлюється початкова координата х
Встановлюється початкова координата у
Встановлюється координата переміщення х1
Встановлюється координата переміщення у1
Переміщення
Опис класів
class TList – призначений для створення класу – контейнеру
class Figure:
поля:
x – координата х
color – колір
nameF – назва
y – координата у
методи:
Figure() – конструктор
void set_x(int x_n) – метод для зміни координати х
int get_x() – метод для отримання координати х
void set_y(AnsiString y_n)– метод для зміни координати у
AnsiString get_y()–метод для отримання координати у
void set_color_nameF(int color_n) – метод для встановлення коліру
int get_color() – метод для отримання коліру
class Ferz:
поля:
x1 – координата х
y1 – координата у
методи:
Figure() – конструктор
void set_x1(int x1_n)– метод для зміни координати х
int get_x1()– метод для отримання координати х
void set_y1(AnsiString y1_n) – метод для зміни координати у
AnsiString get_y1() –метод для отримання координати у
bool move() – метод, що опрацьовує рух фігури
void view(TImage *image) – метод для загрузки картинки
void image(TImage *Image) – метод для відображення фігури на сітці
class FerzList : public TList
методи:
__fastcall ~FerzList() – деструктор
void AddFerz(int s_x, AnsiString s_y, int s_x1, AnsiString s_y1, int s_color) – метод для внесення ферзя до списку
void DelFerz(int i) – метод для видалення ферзя
Ferz* GetFerz(int i) – метод для отримання даних про ферзя
void FindFerz(AnsiString s_nameF, int s_color) – метод для пошуку ферзя
static int __fastcall SortListByInt(void * Item1, void * Item2) – метод-правило сортування списку
void SortByInt() – метод, що сортує список
Опис прецедентів
Прецедент «Запуск програми»
Типовий хід подій
Дії користувача
Відгук програми
Запуск
Шахова дошка, координати фігур, кольори, координати їх переміщення.
Прецедент «Додавання фігури 1 і фігури 2»
Типовий хід подій
Дії користувача
Відгук програми
Натиснули «Фігура 1»
Відкрилося вікно, що фігура може знаходитися у данних кординатах.
Ввели координати для другої фігури, натиснули «Фігура 2»
Відкрилося вікно, що фігура може знаходитися у данних координатах.
Прецедент «Додавання фігури 1 і фігури 2»
Альтернативний хід подій
Дії користувача
Відгук програми
Ввели не правильні координати
Виведено повідомлення про неправильність координат
Прецедент «Видалення фігури»
Типовий хід подій
Дії користувача
Відгук програми
Ввели дані в поле «координати», натиснули «видалити»
Фігуру видалено.
Прецедент «Переміщення фігури»
Типовий хід подій
Дії користувача
Відгук програми
Натиснули «Перемісти ф1»
Відкрилося вікно, що фігура може знаходитися у данних кординатах
Натиснули «Перемісти ф2»
Відкрилося вікно, що фігура може знаходитися у данних кординатах
Прецедент «Переміщення фігури»
Альтернативний хід подій
Дії користувача
Відгук програми
3. Ввели не правильні дані
4. Виведено повідомлення про неправильність координат.
Прецедент «Вихід з програми»
Типовий хід подій
Дії користувача
Відгук програми
Натиснули «закрити програму»
Програма закрилась
Опис програмного інтерфейсу користувача
/
TImage TButton TTextBox TLabel TComboBox
Тестовий приклад/
Рис. 4. Тестовий приклад
Текст програми
Unit1.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
//Ferz F;
//Ferz F2;
FerzList *F = new FerzList();
void __fastcall TForm1::Button2Click(TObject *Sender)
{
exit(1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
// F.AddFerz(
F->AddFerz(StrToInt(Edit1->Text), Edit2->Text, StrToInt(Edit4->Text), Edit5->Text,ComboBox1->ItemIndex);
// F.set_color_nameF(ComboBox1->ItemIndex);
// F.set_x(StrToInt(Edit1->Text));
// F.set_y(Edit2->Text);
// F.set_x1(StrToInt(Edit4->Text));
// F.set_y1(Edit5->Text);
if(F->GetFerz(0)->move()){
F->GetFerz(0)->set_x1(StrToInt(Edit1->Text));
F->GetFerz(0)->set_y1(Edit2->Text);
F->GetFerz(0)->image(Image1);
Image1->Visible=true;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
if(F->GetFerz(0)->get_x()==0)
ShowMessage("Задайте спочатку координати фігури");
else
{
F->GetFerz(0)->set_x1(StrToInt(Edit4->Text));
F->GetFerz(0)->set_y1(Edit5->Text);
if(F->GetFerz(0)->move())
{
F->GetFerz(0)->image(Image1);
F->GetFerz(0)->set_x(StrToInt(Edit4->Text));
F->GetFerz(0)->set_y(Edit5->Text);
Image1->Visible=true;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
/*
F2.set_color_nameF(ComboBox1->ItemIndex);
F2.set_x(StrToInt(Edit1->Text));
F2.set_y(Edit2->Text);
F2.set_x1(StrToInt(Edit4->Text));
F2.set_y1(Edit5->Text);
*/
F->AddFerz(StrToInt(Edit1->Text), Edit2->Text, StrToInt(Edit4->Text), Edit5->Text,ComboBox1->ItemIndex);
if(F->GetFerz(1)->move()){
F->GetFerz(1)->set_x1(StrToInt(Edit1->Text));
F->GetFerz(1)->set_y1(Edit2->Text);
F->GetFerz(1)->image(Image3);
Image3->Visible=true;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{
if(F->GetFerz(1)->get_x()==0)
ShowMessage("Задайте спочатку координати фігури");
else
{
F->GetFerz(1)->set_x1(StrToInt(Edit4->Text));
F->GetFerz(1)->set_y1(Edit5->Text);
if(F->GetFerz(1)->move())
{
F->GetFerz(1)->image(Image3);
F->GetFerz(1)->set_x(StrToInt(Edit4->Text));
F->GetFerz(1)->set_y(Edit5->Text);
Image3->Visible=true;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button6Click(TObject *Sender)
{
if(F->Count>=1)
{
F->DelFerz(0);
Image1->Visible=false;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button7Click(TObject *Sender)
{
if(F->Count>=2)
{
F->DelFerz(1);
Image3->Visible=false;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image2Click(TObject *Sender)
{
}
//---------------------------------------------------------------------------
Unit1.h
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <jpeg.hpp>
#include <Dialogs.hpp>
//#include <list.h>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TImage *Image1;
TButton *Button1;
TButton *Button2;
TEdit *Edit1;
TEdit *Edit2;
TLabel *Label1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label4;
TEdit *Edit4;
TLabel *Label5;
TEdit *Edit5;
TLabel *Label6;
TLabel *Label7;
TImage *Image2;
TComboBox *ComboBox1;
TButton *Button3;
TButton *Button4;
TButton *Button5;
TImage *Image3;
TButton *Button6;
TButton *Button7;
void __fastcall Button2Click(TObject *Sender);
void __fastcall Button1Click(TObject *Sender);
void __fastcall Button3Click(TObject *Sender);
void __fastcall Button4Click(TObject *Sender);
void __fastcall Button5Click(TObject *Sender);
void __fastcall Button6Click(TObject *Sender);
void __fastcall Button7Click(TObject *Sender);
void __fastcall Image2Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
class Figure
{
protected:
int x,color;
public:
AnsiString nameF, y;
Figure(){
x=0;
nameF='?';
y='?';
color=
06.02.2014 00:02-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора