Объектно-ориентированное программирование

Введение 1. Теоретическая часть 1.1 Постановка задачи 1.2 Анализ проблемы и алгоритм реализации 1.3 Схематическое представление классов 1.4 Схематическое представление структур 2. Практическая часть 2.1 Разработка необходимых классов без программной реализации методов 2.2 Добавление и удаление объекта 2.3 Сохранение и загрузка состояния объектов в классе 2.4 Использование дружественных классов 2.5 Программная реализация методов 2.6 Реализация исключений в диалоговых окнах 2.7 Программная реализация тестового приложения 2.8 Руководство к использованию Заключение Список использованной литературы Приложения

Введение

Объектно-ориентированное программирование (ООП) – подход в программировании, в котором основными концепциями есть понятия об объектах и классах. Данная концепция в настоящее время является ведущей в области программирования. Количество прикладных языков программирования, реализующих объектно-ориентированный подход, является наибольшим по отношению к более стандартным подходам (процедурное программирование). Данный подход реализован в таких языках программирования как C#, C++, Java, Python и во многих других. Язык программирования C++ относится к семье языков обладающим C-подобным синтаксисом, из них его синтаксис наиболее близок к C и C#. Язык имеет статическую типизацию, поддерживает полиморфизм, наследование, инкапсуляцию, перегрузку операторов и функций (в том числе операторов явного и неявного приведения типа), атрибуты, их свойства, обобщённые типы и методы, итераторы. В настоящее время, С++ является одним из наиболее востребованных языков программирования в силу своей прямолинейности, скорости и удобства использования. Целью данной курсовой работы является разработка объектной программы «Спортивные лиги» с использованием принципов объектно-ориентированного программирования на языке высокого уровня С++ средствами среды разработки Microsoft Visual Studio 2019. Задачами данной курсовой работы являются:  обозначение классов, объектов и методов, необходимых для решения задачи;  обозначение основных задач описания процесса и построение алгоритма его реализации;  определение необходимого аппарата, применение которого требуется в задаче;  программная реализация задачи средствами Microsoft Visual Studio C++;

1.Теоретическая часть

1.1 Постановка задачи

Задача: разработать объектную программу для хранения и обработки данных о командах и их игроках. В целом команды образуют некоторую спортивную лигу, каждая команда имеет уникальное название и поддерживает список своих игроков. Каждый игрок имеет уникальную фамилию, игровой номер и сумму контракта. Разработка включает в себя определение необходимых объектов и описание их в виде классов, программную реализацию методов добавления и удаления команд в лиге и игроков в команде с подсчетом средней величины контракта. Для объединения команд используется структура данных в виде кольцевой очереди на основе обычного массива. Для объединения игроков внутри команды используется структура данных в виде адресного замкнутого (кольцевого) упорядоченного двунаправленного списка с заголовком. Перечислим требования к классам и методам: — имена классов, свойств и методов должны носить содержательный смысл и соответствовать информационной задаче; — обязательное соблюдение принципа инкапсуляции – использование в классах только закрытых свойств и реализация необходимого набора методов доступа; — наличие двух методов для сохранения всей объектной структуры во внешнем файле с обратной загрузкой, при этом стандартные механизмы сериализации разрешается использовать только как дополнение к самостоятельно реализованным методам; — тестовое оконное приложение должно обладать удобным пользовательским интерфейсом с контролем вводимых данных и отображением текущего состояния объектной структуры с помощью списковых или табличных компонентов;

1.2 Анализ проблемы и алгоритм реализации

Считаем, что каждый игрок должен относиться к определенной команде. Команда, в свою очередь, входит в лигу. То есть мы исключаем возможность нахождения игрока без команды в лиге. Опишем сами классы и их объекты. Для решения задачи опишем следующие классы: — Player (игрок): каждый объект класса имеет уникальную фамилию, игровой номер и сумму контракта, для класса определяется функция уведомления о его создании, каждый игрок принадлежит определенной команде. — Team (команда): каждый объект класса имеет название и уникальный номер для удобства поиска, для класса определяется функция уведомления о его создании, команды делятся на те, что входят в лигу и те, что в лигу не входят. — League (лига): класс имеет уникальный объект, который имеет уникальное название и номер идентификации, в лигу могут входить команды, и игроки, которые принадлежат команде. При функционировании программы могут выполняться следующие операции: — добавление и удаление игрока/команды; — редактирование некоторых параметров объектов; — редактирование параметров шарика; — трансфер игроков между командами; — сохранение информации об игроках и командах в отдельный файл;

1.3 Схематическое представление классов

Представим макеты создания классов с закомментированным описанием документации параметров и свойств соответствующих объектов. Макеты создаются в соответствии с правилами из раздела 1.2. Макет класса Player: class Player { // используем закрытые данные для идентификации параметров private: // перечисляем соответствующие параметры (фамилия, номер, сумма контракта, и принадлежность команде) string name; int number; long int cont; bool belong_to_a_team; public: // описываем функции у класса, обеспечивающие его взаимодействие // используем конструкторы для этого класса по определённому типу приватных данных Player () { // имя строка // номер = 1 // сумма контракта = 1 } Player (string name, int number, long int cont) { // имя строка = name // номер = number // сумма контракта = cont } // функция установления данных set void set (string Player name, int Player number, long int Player cont) { // установим значения для ввода // имя строка = Player name // номер = Player number // сумма контракта = Player cont } // функция вывода данных get void get () { // вывод данных на экран Cout << имя строка << номер << сумма контракта<< endl; } // индикатор создания класса void message_of_creation () { cout<<”Class has been created!”<<endl; } // записать в текстовый файл void (StreamWriter sw) { sw. WriteLine (имя строка); sw. WriteLine (belong_to_a_team); sw. WriteLine (номер); sw. WriteLine (сумма контракта); } // чтение из текстового файла void (StreamReader sr) { Hide (); имя строка = Convert. ToInt32 (sr. ReadLine ()); номер = Convert. ToInt32 (sr. ReadLine ()); сумма контракта = Convert. ToInt32 (sr. ReadLine ()); belong_to_a_team = Convert. ToInt32 (sr. ReadLine ()); Show (); } // Проверка на принадлежность команды void (bool belong_to_a_team) { if (belong_to_a_team) {return true;}; else {return false;}; } // Создание деструктора для удаления данных ~Player () { // new имя строка = Player name; // new номер = Player number; // new сумма контракта = Player cont; delete Player name; delete Player number; delete Player cont; } Макет класса Team: class Team { // используем закрытые данные для идентификации параметров private: // перечисляем соответствующие параметры (название, номер, число игроков, и принадлежность лиге) string team_name; int number; int amount; bool belong_to_a_league; public: // описываем функции у класса, обеспечивающие его взаимодействие // используем конструкторы для этого класса по определённому типу приватных данных Team () { // имя строка // номер = 1 // число игроков = 1 } Team (string team_name, int number, int amount) { // имя строка = team_name // номер = number // число игроков = amount } // функция установления данных set void set (string Team name, int Team number, int Team amount) { // установим значения для ввода // имя строка = Team name // номер = Team number // сумма контракта = Team amount } // функция вывода данных get void get () { // вывод данных на экран Cout << имя строка << номер << число игроков << endl; } // индикатор создания класса void message_of_creation () { cout<<”Class has been created!”<<endl; } // записать в текстовый файл void (StreamWriter sw) { sw. WriteLine (имя строка); sw. WriteLine (belong_to_a_league); sw. WriteLine (номер); sw. WriteLine (число игроков); } // чтение из текстового файла void (StreamReader sr) { Hide (); имя строка = Convert. ToInt32 (sr. ReadLine ()); номер = Convert. ToInt32 (sr. ReadLine ()); число игроков = Convert. ToInt32 (sr. ReadLine ()); belong_to_a_league = Convert. ToInt32 (sr. ReadLine ()); Show (); } Макет класса League: class League { // используем закрытые данные для идентификации параметров private: // перечисляем соответствующие параметры (название, номер) string name; int number; public: // описываем функции у класса, обеспечивающие его взаимодействие // используем конструкторы для этого класса по определённому типу приватных данных League () { // имя строка // номер = 1 } League (string name, int number) { // имя строка = name // номер = number } // функция установления данных set void set (string League name, int League number) { // установим значения для ввода // имя строка = League name // номер = League number } // функция вывода данных get void get () { // вывод данных на экран Cout << имя строка << номер << сумма контракта<< endl; } // индикатор создания класса void message_of_creation () { cout<<”Class has been created!”<<endl; }

1.4 Схематическое представление структур

Представим макеты создания методов с закомментированным описанием документации параметров и свойств. Макеты создаются в соответствии с правилами из раздела 1.2. Для объединения команд используется структура данных в виде кольцевой очереди на основе обычного массива. Для объединения игроков внутри команды используется структура данных в виде адресного замкнутого (кольцевого) упорядоченного двунаправленного списка с заголовком. Макет кольцевой очереди: // определим размер очереди #define Queue_Max 1000 Struct queue { int que[Queue_Max]; int beg, end; } // инициализация очереди void init (struct queue *q) { q-> beg = 1; q-> end = 0; return; } // добавление элемента в очередь void insert (struct queue *q, int x) { if (q-> beg < Queue_Max — 1) { q-> beg ++; q-> queue[q-> beg] = x; } else {return 0;} // вывод элементов void print (struct queue *q) { Int y; if (isempty(q) == 1) { cout <<”Empty!”; return 0; } X = q->queue[q->beg]; q-> beg ++; return x; } Макет двунаправленного списка с заголовком: // определим размер листа Struct list { int field; struct list *prev; struct list *next; } // инициализация листа Struct list *init (int a) { Struct list *lst; lst = (struct list*)malloc(sizeof(struct list)); lst->field = a; lst->prev = Null; lst->next = Null; return(lst); } // добавление элемента в лист struct list * add (list *lst, int number) { struct list *temp, *p; temp = (struct list*)malloc(sizeof(list)); p = lst->next; // сохранение указателя на следующий узел lst->next = temp; // предыдущий узел указывает на создаваемый temp->field = number; // сохранение поля данных добавляемого узла temp->next = p; // новый узел указывает на следующий узел temp->prev = lst; // новый узел указывает на предыдущий узел if (p != NULL) p->prev = temp; return(temp); } // удаление элементов struct list * deletelem(list *lst) { struct list *prev, *next; prev = lst->prev; // узел, предшествующий lst next = lst->next; // узел, следующий за lst if (prev != NULL) prev->next = lst->next; // переставляем указатель if (next != NULL) next->prev = lst->prev; // переставляем указатель free(lst); // освобождаем память удаляемого элемента return(prev); } // обмен узлов информации struct list * swap(struct list *lst1, struct list *lst2, struct list *head) { // Возвращает новый корень списка struct list *prev1, *prev2, *next1, *next2; prev1 = lst1->prev; // узел предшествующий lst1 prev2 = lst2->prev; // узел предшествующий lst2 next1 = lst1->next; // узел следующий за lst1 next2 = lst2->next; // узел следующий за lst2 if (lst2 == next1) // обмениваются соседние узлы { lst2->next = lst1; lst2->prev = prev1; lst1->next = next2; lst1->prev = lst2; if(next2 != NULL) next2->prev = lst1; if (lst1 != head) prev1->next = lst2; } else if (lst1 == next2) // обмениваются соседние узлы { lst1->next = lst2; lst1->prev = prev2; lst2->next = next1; lst2->prev = lst1; if(next1 != NULL) next1->prev = lst2; if (lst2 != head) prev2->next = lst1; } else // обмениваются отстоящие узлы { if (lst1 != head) // указатель prev можно установить только для элемента, prev1->next = lst2; // не являющегося корневым lst2->next = next1; if (lst2 != head) prev2->next = lst1; lst1->next = next2; lst2->prev = prev1; if (next2 != NULL) // указатель next можно установить только для элемента, next2->prev = lst1; // не являющегося последним lst1->prev = prev2; if (next1 != NULL) next1->prev = lst2; } if (lst1 == head) return(lst2); if (lst2 == head) return(lst1); return(head); }

2. Практическая часть

2.1 Разработка необходимых классов без программной реализации методов

Необходимыми классами задачи являются игрок, команда, лига. Макеты классов представлены в разделе 1.3. Предоставим результаты создания классов на рисунках с участками кода и выполнения. int main(int argc, const char* argv[]) { Team team1; // create a team team1.team_message_of_creation(); // check if created team1.set_team(«Dynamo», 1); // set parameters Player player1; // create a player player1.message_of_creation(); // check if created player1.set(«Kushnarev», 1, 1000000000); // set parameters player1.get(); // print parameters team1.set_team_to_a_player(player1); // set a team to a player Player player2; player2.set(«Minenko», 2, 20000000); player2.get(); team1.set_team_to_a_player(player2); Player player3; player1.set(«Khvastunov», 3, 30000000); player1.get(); team1.set_team_to_a_player(player3); Player player4; player1.set(«Ilyk», 4, 4000000); player1.get(); team1.set_team_to_a_player(player4); Player player5; player1.set(«Berezin», 5, 3100000000); player1.get(); team1.set_team_to_a_player(player5); cin.get(); return 0; } Предоставим результат выполнения на рис.2.1. Рис.2.1 Создание команды из 5 человек Выводим число игроков в команде (рис.2.2). Team team1; // create a team team1.team_message_of_creation(); // check if created team1.set_team(«Dynamo», 1); // set parameters team1.amount() Рис.2.2 Число игроков Создадим теперь лигу и проверим, входит ли команда в лигу (рис.2.3). League Accel; Accel.league_message_of_creation(); Team team1; // create a team team1.team_message_of_creation(); // check if created team1.set_team(«Dynamo», 1); // set parameters Accel.set_league_to_a_team(team1); Accel.set_league_to_a_team(); cin.get(); return 0; Рис.2.3 Создание лиги и проверка Далее приводим процедуры добавления и удаления элементов.

2.2 Добавление и удаление объекта

Приводим реализацию программного кода по добавлению и удалению элементов. Сначала приводим код использования деструктора, далее через создание диалогового окна. Реализация конструктор – деструктор. Player() { name = «Ivanov»; number = 1; cont = 1; } Player(string Player_name, int Player_number, long int Player_cont) { name = Player_name; number = Player_number; cont = Player_cont; get(); cout << endl; } ~Player() { cout << «Classs has been deleted!» << endl; } Результат удаления на рисунке 2.4. Рис.2.4 Удаление Для диалогового окна имеем следующую реализацию. Сначала рассмотрим добавление игрока и редактирование параметров. private void button1_Click(object sender, EventArgs e) { // переменная, хранящая направление движения шаров int v = 0; // создание диалогового окна Form2 Dialog = new Form2(); // установка начальных значений компонентов Dialog.Text = «Добавление игрока»; Dialog.Name_TB.Text = «Параметр 1»; Dialog.Number_TB.Text = «Параметр 2»; // вызов окна и определение резултатов его работы if (Dialog.ShowDialog() == DialogResult.OK) { if (Dialog.radioButton1.Checked) v = -1; else if (Dialog.radioButton2.Checked) v = 1; // добавление нового игрока satellite = new Player(Space, Space.nextN, Convert.ToInt32(Dialog.Number_TB.Text), v, Convert.ToInt32(Dialog.Name_TB.Text)); // сохранение номера Space.nextN = satellite.num; // добавление игрока в список отображения listBox1.Items.Add(satellite); Save_ED(true); } Теперь рассмотрим удаление игрока из команды. private void button2_Click(object sender, EventArgse) { if (listBox1.SelectedIndex!= -1) { // запоминание параметров игрока Player sat = listBox1.SelectedItem as Player; // перед удалением необходимо стереть игрока sat.Hide(); Space.S_picture.Refresh(); // удаляем игрока listBox1.Items.RemoveAt(listBox1.SelectedIndex); } else MessageBox.Show(«не выбран шар для удаления»); // если в списке нет элементов, то // запрет действий Save_ED(false); } Определим реализацию отдельной кнопки редактирования параметров игроков. private void button3_Click(object sender, EventArgs e) { // проверка наличия игроков if (listBox1.SelectedIndex!= -1) { // создание диалоговой формы Form2 Dialog = new Form2(); Dialog.Text = «Изменение параметров игроков»; // запоминание параметров игрока Player satel = listBox1.SelectedItem as Shar; Dialog.Name_TB.Text = Convert.ToString(satel.radS); Dialog.Number_TB.Text = Convert.ToString(satel.speed); if (satel.v == -1) Dialog.radioButton1.Checked = true; else Dialog.radioButton2.Checked = true; // запоминание измененных значений if (Dialog.ShowDialog() == DialogResult.OK) { satel.Hide(); Space.S_picture.Refresh(); satel.Name = Convert.ToInt32(Dialog.Name_TB.Text); satel.Number = Convert.ToInt32(Dialog.Number_TB.Text); if (Dialog.radioButton1.Checked) satel.v = -1; else if (Dialog.radioButton2.Checked) satel.v = 1; } } else MessageBox.Show(«Не выбран игрок»); }

2.3 Сохранение и загрузка состояния объектов в классе

При сохранении значений будем использовать стандартный подход с использованием диалогового окна. Реализация имеет следующий вид по отношению к разделам 2.2. private void button4_Click(object sender, EventArgs e) { // подготовка диалогового окна saveFileDialog1.FileName = «Сохранение»; // вызов диалогового окна и определение результатов его работы if (saveFileDialog1.ShowDialog() == DialogResult.OK) { // остановка таймера, для того чтобы во время записи не произошло перемещение игроков внутри лиги. timer1.Enabled = false; // блок try. finally try { // определение расширения файла if (new FileInfo(saveFileDialog1.FileName).Extension == «. dat») { // создание потока данных using (BinaryWriter bw = new BinaryWriter(new FileStream(this.saveFileDialog1.FileName, FileMode.Create))) { // сохранения состояния League.Save(bw); // сохранение количества игроков закрепленных за командами bw.Write(listBox1.Items.Count); // сохранение игроков for (int i = 0; i < listBox1.Items.Count; i++) { satellite = listBox1.Items[i] as Player; satellite.Save(bw); } } } else { // создание текстового потока данных using (StreamWriter sw = new StreamWriter(new FileStream(this.saveFileDialog1.FileName, FileMode.Create))) { Space.Save(sw); // сохранение количества команд Team.WriteLine(listBox1.Items.Count); // сохранение игроков for (int i = 0; i < listBox1.Items.Count; i++) { satellite = listBox1.Items[i] as Player; satellite.Save(sw); } } } } finally { // запуск таймера timer1.Enabled = true; } } } При загрузке необходимых атрибутов из окна с сохранением параметров объектов классов. private void button5_Click(object sender, EventArgs e) { // подготовка диалогового окна openFileDialog1.FileName = «»; // вызов диалогового окна и определение результатов if (openFileDialog1.ShowDialog() == DialogResult.OK) { // отановка таймера timer1.Enabled = false; try { // удаление всех игроков foreach(Player sat in listBox1.Items) sat.Hide(); // удаление списка команд listBox1.Items.Clear(); // очистка строки состояния namePlayer_TS.Text = «»; numberPlayer_TS.Text = «»; League_TS.Text = «»; // определение расширения файла if (new FileInfo(openFileDialog1.FileName).Extension == «. dat») { // создание потока данных using (BinaryReader br = new BinaryReader(File.Open(openFileDialog1.FileName, FileMode.Open))) { // загрузка области Space.Load(br); // чтение количества игроков int c = br.ReadInt32(); // загрузка значений for (int i = 0; i < c; i++) { Player sat = new Player(Team); sat.Load(br); listBox1.Items.Add(sat); } } } else { // создание текстового потока данных using (StreamReader sr = new StreamReader(File.Open(openFileDialog1.FileName, FileMode.Open))) { { Team.Load(sr); int c = Convert.ToInt32(sr.ReadLine()); for (int i = 0; i < c; i++) { Player sat = new Player(Team); sat.Load(sr); listBox1.Items.Add(sat); } } } } } finally { // запуск таймера timer1.Enabled = true; // установка времени Change_ED(false); Del_ED(false); Save_ED(true); } } }

2.4 Использование дружественных классов

Дополнительно рассмотрим реализацию аналогов установки параметров для игроков в командах при помощи метода «дружественного класса». Этот подход позволяет получать доступ к замкнутым атрибутам класса, реализация для нашей задачи в виде установки и получения значений имеет следующий вид. class League; class Team; class Player { friend class Team; // we use friend class to manage players into teams private: string name; // unique surname of player int number; // unique player id (number) long int cont; // unique player contract sum string belong_to_team; // we consider that player belongs to a particular team public: Player() { name = «Ivanov»; number = 1; cont = 1; } Player(string Player_name, int Player_number, long int Player_cont) { name = Player_name; number = Player_number; cont = Player_cont; get(); cout << endl; } void set (string Player_name, int Player_number, long int Player_cont) { name = Player_name; number = Player_number; cont = Player_cont; } void get () { cout << «Player’s surname is — » << name << «, player’s number is — » << number << «, player’s sum of contract is — » << cont << endl; } void message_of_creation () { cout << «Class Player was succesfully created!» << endl; } ~Player() { cout << «Classs has been deleted!» << endl; } }; class Team { friend class League; // private: string team_name; int team_id; string belong_to_a_league; public: void set_team (string Team_name, int Team_id) { team_name = Team_name; // unique name for a team team_id = Team_id; // unique id to distinguish teams } void get_team () { cout << «Name of a team is — » << team_name << «, Team’s number is — » << team_id << endl; } void set_team_to_a_player (Player &pl) { // this where we set a team to a player pl.belong_to_team = team_name; cout << «Player’s team is — » << pl.belong_to_team << endl; } void team_message_of_creation () { cout << «Class Team was succesfully created!» << endl; } void delete_player_from_a_team () { } void count_average_of_contract (Player& pl) { } }; class League { private: string league_name; int league_id; public: void league_message_of_creation() { cout << «Class League was succesfully created!» << endl; } void set_league (string League_name, int League_id) { league_name = League_name; // unique name for a team league_id = League_id; // unique id to distinguish teams } void get_league () { cout << «Name of a league is — » << league_name << «, League’s number is — » << league_id << endl; } void set_league_to_a_team (Team &tm) { // this where we set a team to a player tm.belong_to_a_league = league_name; cout << «Dynamo is in Accel » << tm.belong_to_a_league << endl; } void delete_team_from_a_league() { } };

2.5 Программная реализация методов

В данном разделе мы приводим реализацию методов, макеты которых мы рассмотрели в разделе 1.4. Данные методы представляют собой структуры данных в виде адресного замкнутого (кольцевого) упорядоченного двунаправленного списка и кольцевой очереди на основе обычного массива. struct queue{ int que[Queue_Max]; int beg, end; } // инициализация очереди void init(struct queue* q) { q->beg = 1; q->end = 0; return; } // добавление элемента в очередь void insert(struct queue* q, int x) { if (q->beg < Queue_Max — 1) { q->beg++; q->queue[q->beg] = x; } else { return 0; } // вывод элементов void print(struct queue* q) { Int y; if (isempty(q) == 1) { cout << ”Empty!”; return 0; } X = q->queue[q->beg]; q->beg++; return x; } Макет двунаправленного списка с заголовком : // определим размер листа Struct list{ int field; struct list* prev; struct list* next; } // инициализация листа Struct list* init(int a) { Struct list* lst; lst = (struct list*)malloc(sizeof(struct list)); lst->field = a; lst->prev = Null; lst->next = Null; return(lst); } // добавление элемента в лист struct list* add(list* lst, int number) { struct list* temp, * p; temp = (struct list*)malloc(sizeof(list)); p = lst->next; // сохранение указателя на следующий узел lst->next = temp; // предыдущий узел указывает на создаваемый temp->field = number; // сохранение поля данных добавляемого узла temp->next = p; // новый узел указывает на следующий узел temp->prev = lst; // новый узел указывает на предыдущий узел if (p != NULL) p->prev = temp; return(temp); } // удаление элементов struct list* deletelem(list* lst) { struct list* prev, * next; prev = lst->prev; // узел, предшествующий lst next = lst->next; // узел, следующий за lst if (prev != NULL) prev->next = lst->next; // переставляем указатель if (next != NULL) next->prev = lst->prev; // переставляем указатель free(lst); // освобождаем память удаляемого элемента return(prev); } // обмен узлов информации struct list* swap(struct list* lst1, struct list* lst2, struct list* head) { // Возвращает новый корень списка struct list* prev1, * prev2, * next1, * next2; prev1 = lst1->prev; // узел предшествующий lst1 prev2 = lst2->prev; // узел предшествующий lst2 next1 = lst1->next; // узел следующий за lst1 next2 = lst2->next; // узел следующий за lst2 if (lst2 == next1) // обмениваются соседние узлы { lst2->next = lst1; lst2->prev = prev1; lst1->next = next2; lst1->prev = lst2; if (next2 != NULL) next2->prev = lst1; if (lst1 != head) prev1->next = lst2; } else if (lst1 == next2) // обмениваются соседние узлы { lst1->next = lst2; lst1->prev = prev2; lst2->next = next1; lst2->prev = lst1; if (next1 != NULL) next1->prev = lst2; if (lst2 != head) prev2->next = lst1; } else // обмениваются отстоящие узлы { if (lst1 != head) // указатель prev можно установить только для элемента, prev1->next = lst2; // не являющегося корневым lst2->next = next1; if (lst2 != head) prev2->next = lst1; lst1->next = next2; lst2->prev = prev1; if (next2 != NULL) // указатель next можно установить только для элемента, next2->prev = lst1; // не являющегося последним lst1->prev = prev2; if (next1 != NULL) next1->prev = lst2; } if (lst1 == head) return(lst2); if (lst2 == head) return(lst1); return(head); }

2.6 Реализация исключений в диалоговых окнах

В данном разделе диалоговое окно работы с командами обеспечивает задание параметров игроков в команде: уникальную фамилию, игровой номер и сумму контракта. // определение результата закрытия формы if (DialogResult == DialogResult.OK) // используется для обработки ошибок ввода данных try { // проверка ввода параметров игрока if (Name_TB.Text.Trim() == «») { Name_TB.Focus(); throw new Exception(«Вы не ввели данные об игроке»); } // проверка ввода скорости вращения if (Number_TB.Text.Trim() == «») { Number_TB.Focus(); throw new Exception(«Вы не ввели данные об игроке»); } // проверка выбора направления движения if (!radioButton1.Checked && !radioButton2.Checked) { groupBox1.Focus(); throw new Exception(«Вы не ввели данные о командах»); } // проверка введенных значений на правильность try { int number = Convert.ToInt32(Speed_TB.Text); if (number < 1 || number > 11) { Number_TB.Focus(); throw new Exception(«Информация отсутствует»); } } catch (FormatException) { e.Cancel = true; Number_TB.Focus(); MessageBox.Show(«Скорость должна быть целым числом»); return; } try { int name = Convert.ToInt32(Name_TB.Text); { Name_TB.Focus(); throw new Exception(«Радиус шара должен быть не менее 0 и не более 40 символов «); } } catch (FormatException) { e.Cancel = true; Name_TB.Focus(); MessageBox.Show(«Название»); return; } } // обработка всех других ошибок catch (Exception E) { e.Cancel = true; MessageBox.Show(E.Message); } }

2.7 Программная реализация тестового приложения

Приводим скриншот программной реализации (рис.2.5). Рис.2.5 Программная реализация

2.8 Руководство к использованию

В начальном состоянии (после запуска программы) возможными являются два основных действия: добавление игрока и загрузка ранее сохранённого состояния. Добавление команды осуществляется с помощью кнопки «Добавить команду», кнопки на панели инструментов или пункта меню » Добавить игрока». Удаление выбранного игрока осуществляется с помощью кнопки «Удалить шар», кнопки на панели инструментов или пункта меню » Удалить игрока». Изменение параметров выбранного игрока осуществляется с помощью кнопки «Редактировать игрока», кнопки на панели инструментов или пункта меню » Редактировать игрока». Загрузка сохранённого состояния программы осуществляется с помощью кнопки «Загрузить данные», кнопки на панели инструментов или пункта меню » Загрузить данные об игроке». При выполнении команды в диалоговом окне требуется указать имя файла. Сохранение состояния программы осуществляется с помощью кнопки на панели инструментов или пункта меню «Сохранить данные». Тип файлов сохранения определяется по тому же алгоритму, что и при загрузке. После добавления игрока или загрузки сохранённого состояния становится доступным операция сохранения текущего состояния, которая заново блокируется при удалении последнего игрока. Для выполнения операций удаления или изменения параметров некоторого игрока, он должен быть выбран в списке игроков.

Заключение

В ходе данной курсовой работе удалось разработать программу с использованием компонентов среды визуального проектирования Visual Studio C++. Выполнение курсовой работы было разделено на два этапа:  теоретический анализ поставленной задачи, включающий в себя постановку задачи, выделение необходимых классов, выделение основных действия и алгоритмов их реализации, определение структурных методов с реализованными макетами;  программная реализация задачи средствами Visual C++, включающая в себя реализацию основных классов, реализацию основных структур данных, реализацию классов диалоговых форм и окон, руководства по использовании программы. Итогом курсовой работы можно считать практический опыт по применению знаний в области создания алгоритмов, навыков программирования на языке C++ и создании приложений в Visual Studio, полученных в ходе курса «ООП».

Список используемой литературы

1. Основы алгоритмизации и программирования на С++ — учебное издание — Беспалов С.А. — Минск — 2017 г. — 71 с. 2. Введение в С++ часть 2: метод. указ. — /БМГУ — сост. И.Н. Блинов, В.С. Романчик — Минск — 2014 г. — 69 с. 3. Лекции и практики на С/С++ — учебное издание — Гусин В.И. — Москва — 2018 г. — 283 с. 4. Основы алгоритмизации и программирования в С++. — /СПГУт — сост. В.Л. Бусько, С.Ю. Наровицкий – Санкт-Петербург — 2011 г. — 181 с. 5. Практика программирования на С++ — учебное издание — Полякова О.Ф. — Киев — 2015 г. — 44 с. 6. Программирование в среде Visual Studio — /НСГУ — сост. В.И. Гусин, О.Л. Викентьева — Новороссийск — 2010 г. — 111 с. 7. Язык программирования С++ специальное издание Страуструп В.И. — Москва — 2011 г. — 1135 с. 8. Стандартный С++ — сост. В.В. Подбельский- Новокузнецк — 2016 г. – 688 с. 9. Курсовая работа по программированию на Visual C — учебное издание — Кожемяченко В.И. — Новокузнецк — 2013 г. – 44 с. 10. Программирование в среде Visual C часть 2: метод. указ. — /СибГИУ — сост. В.И. Кожемяченко, С.Ю. Красноперов — Новокузнецк — 2012 г. — 89 с.