Разработка программного модуля для расчета основных геометрических характеристик треугольника

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ Брянский государственный технический университет Учебно-научный технологический институт Кафедра «Автоматизированные технологические системы»

КУРСОВОЙ ПРОЕКТ По дисциплине

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

Руководитель Матлахов В.П.

Студент Брылев В.В.

Брянск 2013

Аннотация

Разработана программа для вычислений геометрических данных фигуры вида треугольник, а именно треугольник и равносторонний треугольник. Реализован ввод координат фигуры, вычисление длин сторон, углов, периметра, площади, поиск максимальной площади, вывод графического представления треугольника, проверка правильности ввода координат, проверка треугольника на равенство сторон. Для равностороннего треугольника реализован расчет биссектрисы поиск минимального ее значения. Также реализован вывод информации и созданных треугольниках в файл. Программа разработана в Turbo C++ Explorer.

• Аннотация
• Введение
• 1. Содержательная постановка и описание задачи
• 2. Атрибуты объекта и представление данных в программе
• 2.1 Алгоритм ввода и вывода данных
• 2.2 Описание подпрограммы создания набора данных
• 3.1 Общие сведения
• 3.2 Функции классов
• 3.3 Конструкторы
• 3.4 Наследование
• 4. Реализация защиты и правильности ввода данных и дополнительных функций
• 5. Диаграмма UML
• 5.1 Отношения между классами
• 5.2 Диаграмма действия
• 6. Хранение данных
• Заключение
• Список используемой литературы
• Приложения

Изучение и практическое освоение методов и средств объектно-ориентированного программирования как одной из основных, перспективных и бурно развивающихся моделей программирования, являющейся в настоящее время базой для создания программных систем и составляющей фундаментальную компоненту образования программиста-профессионала.

Разработанный в данной курсовой работе программный модуль может использоваться для расчета основных геометрических характеристик треугольника, графического представления треугольника на экране, проверка треугольника на равенство сторон.

1. Содержательная постановка и описание задачи

Необходимо разработать программу, реализующую класс треугольник, члены класса — координаты 3-х точек. Предусмотреть в классе методы проверки существования треугольника, вычисления и вывода сведений о фигуре — длины сторон, углы, периметр, площадь. Также должен быть реализован производный класс — равносторонний треугольник, предусмотреть в классе проверку, является ли треугольник равносторонним.

Программа должна искать количество треугольников с минимальной площадью и равносторонний треугольник с наименьшей биссектрисой.

2. Атрибуты объекта и представление данных в программе

2.1 Алгоритм ввода и вывода данных

В программе использованы компоненты:

1) Label

Компонент" Label" (Рис. 1) — предназначен для вывода текста на поверхность формы. Свойства компонента определяют вид и расположение текста.

Свойства компонента определяют вид и расположение текста.

Name — имя компонента. Используется в программе для доступа к компоненту и его свойствам.

Рис. 1. Представление компонента Label в программе.

Caption — отображаемый текст.

Lеft — расстояние от левой границы поля вывода до левой границы формы.

Top — расстояние от верхней границы поля вывода до верхней границы формы.

Height — высота поля вывода.

В данной программе с помощью Label сделаны различные надписи, вывод результата и сообщений.

2) Edit

Компонент «Edit» — представляет собой поле ввода/редактирования строки символов. Основное его свойство Text — текст, находящийся в поле ввода и редактирования. Это свойство имеет строковый тип AnsiString. Это означает, что если пользователь вводит в Edit некоторое число, то необходимо дополнительное преобразование. Кроме функции StrToInt есть обратная к ней IntToStr. Они переводят строку в целое число и целое число в строку соответственно. Кроме этой пары функций имеется пара StrToFloat и FloatToStr, котрые работают с вещественными числами. Основное событие для Edit — это Change. Возникает при изменении свойства Text.

Свойства компонента:

Name — имя компонента. Используется в программе для доступа к компоненту и его свойствам, в частности — для доступа к тексту, введенному в поле редактирования.

Text — т екст, находящийся в поле ввода и редактирования.

Height — высота поля

Width — ширина поля

Font — шрифт, используемый для отображения вводимого текста

В данной программе с помощью Edit реализован ввод значений координат.

программный модуль подпрограмма защита Рис. 2. Представление компонента Edit в программе.

Button

Компонент Button представляет собой командную кнопку.

Свойства компонента:

Name — и мя компонента. Используется в программе для доступа к компоненту и его свойствам

Caption — текст на кнопке

Height — высота кнопки

Width — ширина кнопки

Enabled — признак доступности кнопки. Если значение свойства равно true, то кнопка доступна. Если значение свойства равно false, то кнопка не доступна, например, в результате щелчка на кнопке событие click не возникает visible Позволяет скрыть кнопку (false) или сделать ее видимой (true)

В данной программе с помощью компонента Button производится расчёт параметров фигуры, проверки на, является ли фигура ромбом, так же результатов генерации случайных фигур и вывода информации о генерации в файл.

Рис. 3. Представление компонента Button в программе.

3) Image

Компонент Image представляет собой поле вывода информации на рабочую панель программы.

Рис. 4. Представление компонента Image в программе.

Name — имя компонента. Используется в программе для доступа к компоненту и его свойствам

Height — высота поля

Width — ширина поля В данной программе с помощью компонента Image визуально представляется фигура, координаты которой введены в поля Edit1-Edit6.

4) ComboBox

Компонент «ComboBox» — дает возможность ввести данные в поле редактирования путем набора на клавиатуре или выбором из списка. Для заполнения ComboBox’а используется свойтво Items->Add (Элементы списка — массив строк (нумеруются с нуля)). Также в данной курсовой работе использовалось свойство Itemlndex — Номер элемента, выбранного в списке. Если ни один из элементов списка не был выбран, то значение свойства равно минус 2.

Рис. 5. Представление компонента ComboBox в программе.

2.2 Описание подпрограммы создания набора данных

Получение входных данных — часто самая запутанная часть программы. Причина кроется в том, что программа должна взаимодействовать с пользователем, то есть «мириться» с его прихотями, учитывать принятые соглашения и предусматривать кажущиеся редкими ошибки. Попытки заставить человека вести себя более удобным для машины образом, как правило, рассматриваются как неприемлемые, что справедливо. Задача ввода для функции низкого уровня состоит в последовательном считывании символов и составлении из них лексемы, с которой работают уже функции более высокого уровня.

Для организации записи и чтения файла данных будут использоваться классы библиотека fstream.

Fstream — создание файлового потока для чтения и для записи данных (двунаправленный обмен).

Типы одного объекта или функции должны быть согласованы во всех их описаниях. Должен быть согласован по типам и входной текст, обрабатываемый транслятором, и связываемые части программы. Есть простой, хотя и несовершенный, способ добиться согласованности описаний в различных файлах — включить во входные файлы, содержащие операторы и определения данных, заголовочные файлы, которые содержат интерфейсную информацию. Средством включения текстов служит макрокоманда #include, которая позволяет собрать в один файл (единицу трансляции) несколько исходных файлов программы. Команда

#include «включаемый-файл»

заменяет строку, в которой она была задана, на содержимое файла включаемый-файл. Естественно, это содержимое должно быть текстом на С++, поскольку его будет читать транслятор. Как правило, операция включения реализуется отдельной программой, называемой препроцессором С++. Она вызывается системой программирования перед собственно трансляцией для обработки таких команд во входном тексте [7, c.99].

Для работы с файлами из своей программы необходимо:

1. Подключить заголовочный файл #include содержащий описание функций, позволяющих работать с файловыми потоками.

2. При открытии и очистке файла используются соответствующие функции: ios: app (Открытие файл в режиме записи данных в конец файла) и ios: trunc) (очистка файла).

3. Описание подпрограммы формирования структуры классов

3.1 Общие сведения

Классы и объекты в С++ являются основными концепциями объектно-ориентированного программирования — ООП. Объектно-ориентированное программирование — расширение структурного программирования, в котором основными концепциями являются понятия классов и объектов. Основное отличие языка программирования С++ от С состоит в том, что в С нету классов, а следовательно язык С не поддерживает ООП, в отличие от С++.

Чтобы понять, для чего же в действительности нужны классы, проведём аналогию с каким-нибудь объектом из повседневной жизни, например, с велосипедом. Велосипед — это объект, который был построен согласно чертежам. Так вот, эти самые чертежи играют роль классов в ООП. Таким образом классы — это некоторые описания, схемы, чертежи по которым создаются объекты. Теперь ясно, что для создания объекта в ООП необходимо сначала составить чертежи, то есть классы. Классы имеют свои функции, которые называются методами класса. Передвижение велосипеда осуществляется за счёт вращения педалей, если рассматривать велосипед с точки зрения ООП, то механизм вращения педалей — это метод класса. Каждый велосипед имеет свой цвет, вес, различные составляющие — всё это свойства. Причём у каждого созданного объекта свойства могут различаться. Имея один класс, можно создать неограниченно количество объектов (велосипедов), каждый из которых будет обладать одинаковым набором методов, при этом можно не задумываться о внутренней реализации механизма вращения педалей, колёс, срабатывания системы торможения, так как всё это уже будет определено в классе. Разобравшись с назначением класса, дадим ему грамотное определение.

Классы в С++ — это абстракция описывающая методы, свойства, ещё не существующих объектов. Объекты — конкретное представление абстракции, имеющее свои свойства и методы. Созданные объекты на основе одного класса называются экземплярами этого класса. Эти объекты могут иметь различное поведение, свойства, но все равно будут являться объектами одного класса. В ООП существует три основных принципа построения классов:

1. Инкапсуляция — это свойство, позволяющее объединить в классе и данные, и методы, работающие с ними и скрыть детали реализации от пользователя.

2. Наследование — это свойство, позволяющее создать новый класс-потомок на основе уже существующего, при этом все характеристики класса родителя присваиваются классу-потомку.

3. Полиморфизм — свойство классов, позволяющее использовать объекты классов с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

А теперь вернёмся к классам, для начала рассмотрим структуру объявления классов.

Объявление класса начинается с зарезервированного ключевого слова class, после которого пишется имя класса. В фигурных скобочках, строки 3 - 10 объявляется тело класса, причём после закрывающейся скобочки обязательно нужно ставить точку с запятой, строка 10. В теле класса объявляются три метки спецификации доступа, строки 4, 6, 8, после каждой метки нужно обязательно ставить двоеточие. В строке 4 объявлена метка спецификатора доступа private. Все методы и свойства класса, объявленные после спецификатор доступа private будут доступны только внутри класса. В строке 6 объявлен спецификатор доступа public, все методы и свойства класса, объявленные после спецификатора доступа public будут доступны другим функциям и объектам в программе. Пока на этом остановимся, спецификатор доступа protected разбирать сейчас не будем, просто запомните, что он есть. При объявлении класса, не обязательно объявлять три спецификатора доступа, и не обязательно их объявлять в таком порядке. Но лучше сразу определиться с порядком объявления спецификаторов доступа, и стараться его придерживаться.

Пример структуры объявления класса Treug:

class Treug // Создание класса Треугольник

{public: // Определение видимых методов и переменных

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB, BC, CA, alpha, betta, gamma;

float p, polup, S, t;

// Конструктор класса с параметрами

Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1);

// Конструктор создания объекта типа Треугольник без начальных параметров

Treug ();

~Treug ();

int proverka ();

storona (); // Метод класса для расчета длин сторон треугольника

float putAB (); float putBC (); float putCA ();

ugol (); // Метод класса для расчета углов треугольника

float putAlpha (); float putBetta (); float putGamma ();

float perimetr (); // Метод класса для расчета периметра треугольника

float square (); // Метод класса для расчета площади треугольника

// Метод класса для проверки: является ли треугольник равносторонним

void print (TImage &img); // Метод класса для отрисовки треугольника

};

3.2 Функции классов

Каждый объект имеет какие-то свои свойства или атрибуты, которые характеризуют его на протяжении всей жизни. Атрибуты объекта хранятся в переменных, объявленных внутри класса, которому принадлежит данный объект. Причём, объявление переменных должно выполняться со спецификатором доступа private. Такие переменные называются элементами данных. Так как элементы данных объявлены в private, то и доступ к ним могут получить только методы класса, внешний доступ к элементам данных запрещён. Поэтому принято объявлять в классах специальные методы — так называемые set и get функции, с помощью которых можно манипулировать элементами данных. set-функции инициализируют элементы данных, get-функции позволяют просмотреть значения элементов данных.

Пример использования методов и функция:

storona ();

float putAB ();

float putBC ();

float putCA ();

Пример задание метода (функции) в классе:

{Public:

ugol (); // Метод класса для расчета углов треугольника

float putAlpha ();

float putBetta ();

float putGamma ();

float perimetr ();

};

Пример описание метода (функции) вне класса:

Treug: ugol ()

{t=180/M_PI;

alpha= (acos ((pow (BC, 2) +pow (CA, 2) — pow (AB, 2)) / (2*BC*CA))) *t;

betta= (acos ((pow (AB, 2) +pow (CA, 2) — pow (BC, 2)) / (2*AB*CA))) *t;

gamma= (acos ((pow (AB, 2) +pow (BC, 2) — pow (CA, 2)) / (2*AB*BC))) *t;

};

float Treug: putAlpha () {return alpha; }

float Treug: putBetta () {return betta; }

float Treug: putGamma () {return gamma; }

3.3 Конструкторы

Конструктор — специальная функция, которая выполняет начальную инициализацию элементов данных, причём имя конструктора обязательно должно совпадать с именем класса. Важным отличием конструктора от остальных функций является то, что он не возвращает значений вообще никаких, в том числе и void. В любом классе должен быть конструктор, даже если явным образом конструктор не объявлен (как в предыдущем классе), то компилятор предоставляет конструктор по умолчанию, без параметров.

Пример использования конструкторов в данной программе, использования конструктора Treug, класса Treug, и описание его вне класса:

class Treug

{

public:

.

Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1);

.

};

Treug: Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1)

{

Xa=Xa1; Xb=Xb1;

Xc=Xc1; Ya=Ya1;

Yb=Yb1; Yc=Yc1;

};

3.4 Наследование

Цель объектно-ориентированного программирования состоит в повторном использовании созданных вами классов, что экономит ваше время и силы. Если вы уже создали некоторый класс, то возможны ситуации, что новому классу нужны многие или даже все особенности уже существующего класса, и необходимо добавить один или несколько элементов данных или функций. В таких случаях C++ позволяет вам строить новый объект, используя характеристики уже существующего объекта. Другими словами, новый объект будет наследовать элементы существующего класса (называемого базовым классом). Когда вы строите новый класс из существующего, этот новый класс часто называется производным классом.

Реализация примера наследования в данной программе, класс Treug и его наследник RavnTreug:

class Treug

{public:

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB, BC, CA, alpha, betta, gamma;

float p, polup, S, t;

Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1);

Treug ();

~Treug ();

int proverka ();

storona ();

float putAB ();

float putBC ();

float putCA ();

ugol ();

float putAlpha ();

float putBetta ();

float putGamma ();

float perimetr ();

float square ();

void print (TImage &img);

};

Пример реализации наследования, следующим путём:

class RavnTreug: public Treug

{ float ABravn;

float bis;

public:

int proverkaRavn ();

RavnTreug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1): Treug (Xa1, Xb1, Xc1, Ya1, Yb1, Yc1) {};

~RavnTreug ();

float bissec ();

};

Наследование является фундаментальной концепцией объектно-ориентированного программирования.

4. Реализация защиты и правильности ввода данных и дополнительных функций

При выполнении курсовой работы, я столкнулся с проблемой возможности введения многочисленными способами неверных координат, тем самым вывести программы из рабочего состояния. В связи с этим, мною было решено разработать серию определённых условий, которые помогут отсеять варианты неверного введения координат.

1. Условие первое: Все координаты должны быть заполнены.

Реализация решения проблемы:

void __fastcall TForm1: Edit1Change (TObject *Sender)

{

/*Если Edit1 не заполнен, кнопка Button1 не активна*/

if (Edit1->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

2. Условие первое: В поля ввода Edit можно вводить только числа.

Реализация решения проблемы:

/*Разрешенные символы в Edit1*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

3. Условие третье: координаты вершин не могут совпадать, то есть 2 вершины не могут находиться в одной и той же точки.

Реализация решения проблемы:

if (((MAS [i]. Xa==MAS [i]. Xb) && (MAS [i]. Ya==MAS [i]. Yb) ||

(MAS [i]. Xa==MAS [i]. Xc) && (MAS [i]. Ya==MAS [i]. Yc) ||

(MAS [i]. Xb==MAS [i]. Xc) && (MAS [i]. Yb==MAS [i]. Yc)))

MessageBox (this->Handle, «Вершины треугольника не могут располагаться в 1ой точке» ,

" Ошибка!", MB_OK

Для удобства пользователя было реализовано выполнение кода программы, не только при нажатии кнопки, но при нажатии кнопки Enter. Реализация:

void __fastcall TForm1: EditKeyPress (TObject *Sender, char &Key)

void __fastcall TForm1: FormKeyPress (TObject *Sender, char &Key)

{ if ((Key == VK_RETURN) &&

(Edit1>Text. Length () >0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

}

5. Диаграмма UML

Центральное место в объектно-ориентированном программировании занимает разработка логической модели системы в виде диаграммы классов. Диаграмма классов (class diagram) служит для представления статической структуры модели системы в терминологии классов объектно-ориентированного программирования. Диаграмма классов может отражать, в частности, различные взаимосвязи между отдельными сущностями предметной области, такими как объекты и подсистемы, а также описывать их внутреннюю структуру и типы отношений.

Диаграмма классов представляет собой граф, вершинами которого являются элементы типа «классификатор», связанные различными типами структурных отношений. Диаграмма классов может также содержать интерфейсы, пакеты, отношения и даже отдельные экземпляры, такие как объекты и связи.

Квантор видимости может принимать одно из трех возможных значений и отображается при помощи соответствующих специальных символов:

· «+» обозначает атрибут с областью видимости типа общедоступный (public). Атрибут с этой областью видимости доступен или виден из любого другого класса пакета, в котором определена диаграмма;

· «#» обозначает атрибут с областью видимости типа защищенный (protected). Атрибут с этой областью видимости недоступен или невиден для всех классов, за исключением подклассов данного класса;

· «-» обозначает атрибут с областью видимости типа закрытый (private). Атрибут с этой областью видимости недоступен или невиден для всех классов без исключения.

Квантор видимости может быть опущен. В этом случае его отсутствие просто означает, что видимость атрибута не указывается. Эта ситуация отличается от принятых по умолчанию соглашений в традиционных языках программирования, когда отсутствие квантора видимости трактуется как public или private. Однако вместо условных графических обозначений можно записывать соответствующее ключевое слово: public, protected, private.

5.1 Отношения между классами

Кроме внутреннего устройства или структуры классов на соответствующей диаграмме указываются отношения между классами. При этом совокупность типов таких отношений фиксирована в языке UML и предопределена семантикой этих типов отношений. Базовыми отношениями в языке UML являются:

· зависимости (dependency relationship);

· ассоциации (association relationship);

· обобщения (generalization relationship)

Каждое из этих отношений имеет собственное графическое представление на диаграмме, которое отражает взаимосвязи между объектами соответствующих классов.

Пример взаимосвязи между классами (часть диаграммы из приложения):

Рис. 6. Пример графического представления наследования, и создания треугольников и равносторонних треугольников.

5.2 Диаграмма действия

При моделировании поведения проектируемой системы возникает необходимость не только представить процесс изменения её состояний, но и детализировать особенности алгоритмической и логической операции выполняемой системой реализации. Традиционно для этой цели использовались блок-схема или структурные схемы алгоритмов. В UML для этого используется диаграмма действий.

На диаграмме деятельности отображается логика или последовательность переходов от одной деятельности к другой. При этом внимание фиксируется на результате деятельности. Сам же результат может привести к изменению состояния системы или возвращению некоторого значения.

Графически диаграмма деятельности представляется в форме графа деятельности, вершинами которого является состояние действия, а дугами — переходы от одного состояния в действия к другому.

При этом каждое состояние может являться выполнением операции некоторого класса либо её часть, позволяя использовать диаграмму деятельности для описания реакции на внутренние события системы.

В языке UML действие изображается в виде прямоугольника с закругленными углами, состояния — в виде прямоугольника, переходы — в виде направленных стрелок, элементы выбора — в виде ромбов, линии синхронизации — в виде толстых горизонтальных или вертикальных линий.

Пример реализации диаграммы действий в курсовом проекте:

Рис. 7. Диаграмма Действий.

6. Хранение данных

Для хранения данных в процессе работы программы была реализована структура Ttreug. Структуры — это составные типы данных, построенные с использованием других типов. [8, c.408].

Определение структуры для хранения данных о треугольнике:

typedef struct {

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB;

float BC;

float CA;

float alpha;

float betta;

float gamma;

float perimetr;

float square;

float bis;

int ravn;

int proverka;

} Ttreug;

Типы данных, хранимых в структуре Ttreug представлены на Рис.8

Рис. 8 Типы данных, хранимых в структуре Ttreug.

Заключение

В данном курсовом проекте разработан программный модуль для вычислений геометрических данных фигуры вида треугольник, а именно треугольник и равносторонний треугольник. Реализован ввод координат фигуры, вычисление длин сторон, углов, периметра, площади, поиск максимальной площади, вывод графического представления треугольника, проверка правильности ввода координат, проверка треугольника на равенство сторон. Для равностороннего треугольника реализован расчет биссектрисы поиск минимального ее значения. Также реализован вывод информации и созданных треугольниках в файл.

В этом курсовом проекте использовалась структура классов. Был рассмотрен принцип наследования и создания производных классов.

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

1. Объектно-ориентированное программирование в С++. Лафоре Р.

2. Гради Буч «Объектно-ориентированный анализ и проектирование» 3.Э. Гамма «Приемы объектно-ориентированного проектирования. Паттерны проектирования»

4. Культин, C++ Builder в задачах и примерах-Спб. // Культин Н. Б.: БХВ-Петербург, 2005. — 336 с.

5. Грейди Буч, Джеймс Рамбо, Айвар Джекобсон. Язык UML. Руководство пользователя = The Unified Modeling Language user guide. — 2-е изд. — М., Питер, 2004. — 432 с.

6. Иан Грэхем Объектно-ориентированные методы. Принципы и практика = Object-Oriented Methods: Principles & Practice. — 3-е изд. — М.: «Вильямс», 2004. — С.880.

7. Биллиг В. А. Основы программирования на C++. Интернет-университет информационных технологий — ИНТУИТ. ру, 2006

8. Дейтел Х., Дейтел П. Как программировать на С++: пер. с англ. — М.: «Издательство Бином», 2003 г. — 1021 с.

Приложения

Приложение 1

Листинг программы

// ————————————————————————————-;

#include

#include

#include

#pragma hdrstop

#include «Unit1. h»

// ————————————————————————————-;

#pragma package (smart_init)

#pragma resource «*. dfm»

TForm1 *Form1;

typedef struct // Определение структуры для хранения данных о треугольнике

{

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB;

float BC;

float CA;

float alpha;

float betta;

float gamma;

float perimetr;

float square;

float bis;

int ravn;

int proverka;

} Ttreug;

typedef Ttreug TMaskadr [50];

TMaskadr MAS;

int i;

class Treug // Создание класса Треугольник

{public: // Определение видимых методов и переменных

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB, BC, CA, alpha, betta, gamma;

float p, polup, S, t;

// Конструктор класса с параметрами

Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1);

// Конструктор создания объекта типа Треугольник без начальных параметров

Treug ();

~Treug ();

int proverka ();

storona (); // Метод класса для расчета длин сторон треугольника

float putAB (); float putBC (); float putCA ();

ugol (); // Метод класса для расчета углов треугольника

float putAlpha (); float putBetta (); float putGamma ();

float perimetr (); // Метод класса для расчета периметра треугольника

float square (); // Метод класса для расчета площади треугольника

// Метод класса для проверки: является ли треугольник равносторонним

void print (TImage &img); // Метод класса для отрисовки треугольника

};

// Описание конструктора

Treug: Treug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1)

{

Xa=Xa1; Xb=Xb1; Xc=Xc1;

Ya=Ya1; Yb=Yb1; Yc=Yc1;

};

Treug: Treug () {} // Перегрузка конструктор без параметров

Treug: ~Treug () {

Xa=0; Xb=0; Xc=0;

Ya=0; Yb=0; Yc=0; }

Treug: storona ()

{

AB=sqrt (pow (Xa-Xb,

2) +pow (Ya-Yb,

2));

BC=sqrt (pow (Xb-Xc,

2) +pow (Yb-Yc,

2));

CA=sqrt (pow (Xc-Xa,

2) +pow (Yc-Ya,

2));

};

float Treug: putAB () {return AB; }

float Treug: putBC () {return BC; }

float Treug: putCA () {return CA; }

int Treug: proverka ()

{

if ((AB==BC+CA) || (BC==AB+CA) || (CA==AB+BC)) {return 0; }

else return 1;

};

Treug: ugol ()

{t=180/M_PI;

alpha= (acos ((pow (BC, 2) +pow (CA, 2) — pow (AB, 2)) / (2*BC*CA))) *t;

betta= (acos ((pow (AB, 2) +pow (CA, 2) — pow (BC, 2)) / (2*AB*CA))) *t;

gamma= (acos ((pow (AB, 2) +pow (BC, 2) — pow (CA, 2)) / (2*AB*BC))) *t;

};

float Treug: putAlpha () {return alpha; }

float Treug: putBetta () {return betta; }

float Treug: putGamma () {return gamma; }

float Treug: square ()

{polup= (AB+BC+CA) /2;

S=sqrt (polup* (polup-AB) * (polup-BC) * (polup-CA));

return S;

}

float Treug: perimetr ()

{p=AB+BC+CA;

return p;

};

void Treug: print (TImage &img)

{

float max=Xa;

if (Ya>Xa) {max=Ya; }

if ((Xb>Xa) && (Xb>Ya)) {max=Xb; }

if ((Yb>Xa) && (Yb>Ya) && (Yb>Xb)) {max=Yb; }

if ((Xc>Xa) && (Xc>Ya) && (Xc>Xb) && (Xc>Yb)) {max=Xc; }

if ((Yc>Xa) && (Yc>Ya) && (Yc>Xb) && (Yc>Yb) && (Yc>Xc)) {max=Yc; }

float mashtab=300/max;

img. Canvas->MoveTo (Xa*mashtab, Ya*mashtab);

img. Canvas->LineTo (Xb*mashtab, Yb*mashtab);

img. Canvas->LineTo (Xc*mashtab, Yc*mashtab);

img. Canvas->LineTo (Xa*mashtab, Ya*mashtab);

};

class RavnTreug: public Treug // Создание класса RavnTreug

{ float ABravn;

float bis;

public: // Определение видимых методов и переменных

int proverkaRavn ();

RavnTreug (float Xa1, float Xb1, float Xc1, float Ya1, float Yb1, float Yc1): Treug (Xa1, Xb1, Xc1, Ya1, Yb1, Yc1) {}; // Конструктор класса RavnTreug

~RavnTreug ();

float bissec (); // метод расчета биссектрисы равностороннего треугольника

};

RavnTreug: ~RavnTreug () {}

int RavnTreug: proverkaRavn ()

{ storona ();

int AB1= (int) AB;

int BC1= (int) BC;

int CA1= (int) CA;

if ((AB1==BC1) && (BC1==CA1)) {return 1; }

else return 0;

}

float RavnTreug: bissec ()

{ storona ();

bis= (putAB () *sqrt (3)) /2;

return bis;

}

int countRavn=0;

// ————————————————————————————-;

__fastcall TForm1: TForm1 (TComponent* Owner)

: TForm (Owner)

{

}

// ————————————————————————————-;

void __fastcall TForm1: Button1Click (TObject *Sender)

{

Form1->Height=430;

float Xa, Xb, Xc, Ya, Yb, Yc;

float AB, BC, CA, alpha, betta, gamma;

// Открытие файл Treug. txt в режиме записи данных в конец файла

ofstream book_file («Treug. txt», ios: app);

// Чтение значений координат точек А, В, С из Edit’ов

// и добавление их в массив структуры

MAS [i]. Xa=Xa=StrToFloat (Edit1->Text);

MAS [i]. Ya=Ya=StrToFloat (Edit2->Text);

MAS [i]. Xb=Xb=StrToFloat (Edit3->Text);

MAS [i]. Yb=Yb=StrToFloat (Edit4->Text);

MAS [i]. Xc=Xc=StrToFloat (Edit5->Text);

MAS [i]. Yc=Yc=StrToFloat (Edit6->Text);

if (((MAS [i]. Xa==MAS [i]. Xb) && (MAS [i]. Ya==MAS [i]. Yb) ||

(MAS [i]. Xa==MAS [i]. Xc) && (MAS [i]. Ya==MAS [i]. Yc) ||

(MAS [i]. Xb==MAS [i]. Xc) && (MAS [i]. Yb==MAS [i]. Yc)))

MB_ICONERROR);

else{

Treug tr1 (Xa, Xb, Xc, Ya, Yb, Yc); // Определение объекта типа Treug

tr1. storona (); // Вызов метода расчета длин сторон треугольника

// Закрашивание Canvas

Image1->Canvas->Rectangle (0,0,300,300);

tr1. ugol (); // Вызов метода рассчета углов треугольника

// Вызов методов возврата значений длин сторон треугольника

// и добавление полученных значений в массив структуры

MAS [i]. AB=tr1. putAB ();

MAS [i]. BC=tr1. putBC ();

MAS [i]. CA=tr1. putCA ();

MAS [i]. proverka=tr1. proverka ();

// Вызов методов расчета углов, периметра и площади треугольника

// и добавление полуенных значений в массив структуры

MAS [i]. alpha=tr1. putAlpha ();

MAS [i]. betta=tr1. putBetta ();

MAS [i]. gamma=tr1. putGamma ();

MAS [i]. perimetr=tr1. perimetr ();

MAS [i]. square=tr1. square ();

// Вызов метода проверки: является ли треугольник равносторонним

RavnTreug tr2 (Xa, Xb, Xc, Ya, Yb, Yc); // Определение объекта типа RavnTreug

MAS [i]. ravn=tr2. proverkaRavn ();

MAS [i]. bis=0;

/*Проверка*/

if (MAS [i]. proverka==0)

MessageBox (this->Handle, «Вы построили прямую», «Ошибка!» ,

MB_OK

else {

/*Если треугольник равносторонний*/

if (MAS [i]. ravn==1) {

countRavn++; // Счетчик количества равносторонних треугольников

// Вывод сообщения, что создан равносторонний треугольник

MessageBox (this->Handle, «Вы создали равносторонний треугольник», «УРА!» ,

MB_OK | MB_ICONINFORMATION);

MAS [i]. bis=tr2. bissec (); // Вызов метода расчета биссектрисы

/*Поиск минимальной биссектрисы*/

float min=0;

int masimin=0, masi=0;

min=MAS [i]. bis;

for (masi = 0; masi <= i; masi++) {

if ((MAS [masi]. bis! =0) && (MAS [masi]. bis<=min)) {

min=MAS [masi]. bis;

masimin=masi; }

}

// Вывод в Label13

Label13->Caption="Равносторонний треугольник №"

+IntToStr (masimin+1) +" имеет наименьшую биссектрису равную «

+FloatToStrF (min, ffFixed, 10 000,3) +" см" ;

}

tr1. print (*Image1); // Вызов метода вывода треугольника на Canvas

ComboBox1->Items->Add (i+1); // Добавление номера треугольник в ComboBox1

ComboBox2->Items->Add (i+1); // Добавление номера треугольник в ComboBox2

Label2->Caption=

" AB="+FloatToStrF (MAS [i]. AB, ffFixed, 10 000,3) +" см"

+" nBC="+FloatToStrF (MAS [i]. BC, ffFixed, 10 000,3) +" см"

+" nCA="+FloatToStrF (MAS [i]. CA, ffFixed, 10 000,3) +" см"

+" nAlpha="+FloatToStrF (MAS [i]. alpha, ffFixed, 10 000,3) +" °"

+" nBetta="+FloatToStrF (MAS [i]. betta, ffFixed, 10 000,3) +" °"

+" nGamma="+FloatToStrF (MAS [i]. gamma, ffFixed, 10 000,3) +" °"

+" nP="+FloatToStrF (MAS [i]. perimetr, ffFixed, 10 000,3) +" см"

+" nS="+FloatToStrF (MAS [i]. square, ffFixed, 10 000,3) +" см²″ ;

ComboBox1->ItemIndex=i;

ComboBox2->ItemIndex=i;

i++;

// Вывод в Label10

Label10->Caption="Создано треугольников: «+IntToStr (i) +» n"

+" Из них равносторонних: «+IntToStr (countRavn);

/*Вывод сведений о треугольнике в файл Treug. txt*/

book_file<<" Треугольник №" <<": n"

<<" AB="<<<" см; «<<» «

<<" BC="<<<" см; «<<» «

<<" CA="<<<" см; n"

<<" alpha="<<<" °; «

<<" betta="<<<" °; «

<<" gamma="<<<" °; n"

<<" P="<<<" см; n"

<<" S="<<<" см²; n"

<<" Равносторонний треугольник (0-НЕТ; 1-ДА): «<<<»; nn" ;

/* Поиск треугольника с максимальной площадью*/

float maxSquare=0;

int numMaxSquare=0, numMaxSquare2=0, countfor=0;

maxSquare=MAS. square;

for (countfor = 0; countfor <= i; countfor++) {

if (MAS [countfor]. square>maxSquare) {

maxSquare=MAS [countfor]. square;

numMaxSquare=countfor; }

}

// Вывод в Label14

Label14->Caption="Треугольник №"

+IntToStr (numMaxSquare+1) +" имеет наибольшую площадь равную «

+FloatToStrF (maxSquare, ffFixed, 10 000,3) +" см²″ ;

ComboBox3->Items->Clear ();

for (countfor = 0; countfor <= i; countfor++) {

if ((MAS [countfor]. square==maxSquare) && (countfor! =numMaxSquare)) {

Label16->Caption="Треугольники с такой же площадью: «;

ComboBox3->Items->Add (countfor+1);

ComboBox3->ItemIndex=0;

}

}

}

tr1. ~Treug ();

tr2. ~RavnTreug ();

}

}

// ————————————————————————————-;

void __fastcall TForm1: FormCreate (TObject *Sender)

{

ofstream book_file («Treug. txt», ios: trunc); // очистка файла

i=0;

Image1->Canvas->Rectangle (0,0,300,300);

Label13->Caption="Равносторонний треугольник №??? имеет наименьшую биссектрису равную???" ;

Label14->Caption="Треугольник №??? имеет наибольшую площадь равную???" ;

Label16->Caption="Треугольники с такой же площадью: «;

}

// ————————————————————————————-;

void __fastcall TForm1: ComboBox1Change (TObject *Sender)

{

/*Вывод данных о треугольнике c номером, выбранном в ComboBox1 в Label2*/

int ii, k=0, j=0;

j=i;

k=i;

ii=ComboBox1->ItemIndex;

for (k = 0; k <= j; k++) {

if (k==ii) {

Label2->Caption=

" AB="+FloatToStrF (MAS [k]. AB, ffFixed, 10 000,3) +" см"

+" nBC="+FloatToStrF (MAS [k]. BC, ffFixed, 10 000,3) +" см"

+" nCA="+FloatToStrF (MAS [k]. CA, ffFixed, 10 000,3) +" см"

+" nAlpha="+FloatToStrF (MAS [k]. alpha, ffFixed, 10 000,3) +" °"

+" nBetta="+FloatToStrF (MAS [k]. betta, ffFixed, 10 000,3) +" °"

+" nGamma="+FloatToStrF (MAS [k]. gamma, ffFixed, 10 000,3) +" °"

+" nP="+FloatToStrF (MAS [k]. perimetr, ffFixed, 10 000,3) +" см"

+" nS="+FloatToStrF (MAS [k]. square, ffFixed, 10 000,3) +" см²″ ;

}

}

}

// ————————————————————————————-;

void __fastcall TForm1: ComboBox2Change (TObject *Sender)

{

/*Отрисовка треугольника c номером, выбранном в ComboBox2 на Canvas*/

int ii, k=0, j=0;

j=i;

k=i;

ii=ComboBox2->ItemIndex;

Image1->Canvas->Rectangle (0,0,300,300);

for (k = 0; k <= j; k++) {

if (k==ii) {

Treug tr2 (MAS [k]. Xa, MAS [k]. Xb, MAS [k]. Xc, MAS [k]. Ya, MAS [k]. Yb, MAS [k]. Yc);

tr2. storona ();

tr2. print (*Image1);

}

}

}

// ————————————————————————————-;

void __fastcall TForm1: Edit1KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit1*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit1*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit2KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit2*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit2*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit3KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit3*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit3*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit4KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit4*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit4*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit5KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit5*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit5*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit6KeyPress (TObject *Sender, char &Key)

{

/*Выполнение кода кнопки Button1 при нажатии Enter в Edit6*/

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

/*Разрешенные символы в Edit6*/

if ((Key < '0' || Key > '9') && Key! = 8) Key= 0;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit1Change (TObject *Sender)

{

/*Если Edit1 не заполнен, кнопка Button1 не активна*/

if (Edit1->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit3Change (TObject *Sender)

{

/*Если Edit3 не заполнен, кнопка Button1 не активна*/

if (Edit3->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit5Change (TObject *Sender)

{

/*Если Edit5 не заполнен, кнопка Button1 не активна*/

if (Edit5->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit2Change (TObject *Sender)

{

/*Если Edit2 не заполнен, кнопка Button1 не активна*/

if (Edit2->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit4Change (TObject *Sender)

{

/*Если Edit4 не заполнен, кнопка Button1 не активна*/

if (Edit4->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: Edit6Change (TObject *Sender)

{

/*Если Edit6 не заполнен, кнопка Button1 не активна*/

if (Edit6->Text. Length () == 0) {

Button1->Enabled=false;

}

else Button1->Enabled=true;

}

// ————————————————————————————-;

void __fastcall TForm1: FormKeyPress (TObject *Sender, char &Key)

{

if ((Key == VK_RETURN) && (Edit1->Text. Length () > 0) && (Edit2->Text. Length () > 0)

&& (Edit3->Text. Length () > 0) && (Edit4->Text. Length () > 0)

&& (Edit5->Text. Length () > 0) && (Edit6->Text. Length () > 0))

{Button1->Default = True; }

}

// ————————————————————————————-;