Реализовать выделенные функции

#include"Triangle.h"
#include<iostream>
usingnamespacestd;
 
int Menu();
[COLOR="Red"][CODE]voidShow(Triangle*[], int);//показать информацию о всех треугольниках массива
voidMove(Triangle*[], int);//переместить указанный пользователем треугольник из массива на //заданную пользователем точку 
voidFindMax(Triangle*[], int);//найти в массиве треугольник с большей площадью и вывести его имя[/CODE][/COLOR]
 
void main(){
    setlocale(LC_ALL, "Russian");
 
Point p1(0,0), p2(0.5,1),p3(1,0),p4(0,4.5), p5(2,1),p6(2,0),p7(2,2),p8(3,0);
 
//Треугольники
Triangle tr1(p1,p2,p3,"triangleA");
Triangle tr2(p1,p4,p8,"triangleB");
Triangle tr3(p1,p5,p6,"triangleC");
Triangle tr4(p1,p7,p8,"triangleD");
 
//определение массива указателей на треугольники
Triangle *ptrTr[]={&tr1, &tr2, &tr3, &tr4};
int n=sizeof(ptrTr)/sizeof(ptrTr[0]);//определяем длину массива
 
bool done=false;
    while(!done){
        switch(Menu()){
        case 1:
            Show(ptrTr,n);
            break;
        case 2:
            Move(ptrTr,n);
            break;
        case 3:
            FindMax(ptrTr,n);
            break;
 
        case 4:
            done=true;
            break;
        }
    }
    
 
}
 
int Menu(){
    intvibor=0;
    do{
    cout<<"\n\n==================================Меню========================"<<endl;
    cout<<"1. вывести все объекты"<<endl;
    cout<<"2. переместить"<<endl;
    cout<<"3. найти максимальный"<<endl;
    cout<<"4. выход"<<endl;
    cin>>vibor;
    }while(vibor<1 || vibor>4);
    returnvibor;
}
 
void Show(Triangle *ptrTr[], int k){
    cout<<"\n=======Треугольники========"<<endl;
    …
 
}
void Move(Triangle*ptrTr[], int k){
    cout<<"\n=======Перемещение========"<<endl;
    cout<<"Введите номер треугольника (от 1 до "<<k<<"),который желаете переметить: ";
    …
}
voidFindMax(Triangle*ptrTr[], int k){
    cout<<"\n=======Поиск максимального треугольника========"<<endl;
    …
 
    cout<<"Треугольник с максимальной площадью: "<<maxTr.getId()<<endl;
 
}
 
 
 
 
 
 
//-перемещение на плоскости
 
void Triangle::Move(Point dp){
    v1+=dp; v2+=dp; v3+=dp;
}

#include <iostream>
 
#include <math.h> //для sqrt
 
#include <iostream>
 
#include <iomanip> 
 
#include <cstring>//для strlen, strcat, strcpy
 
//using namespace std;
 
 
int Menu();
 
 
void Show(Triangle* [], int);//показать информацию о всех треугольниках массива
 
 
void Move(Triangle* [], int);
 
void FindMax(Triangle* [], int);
 
 
 
 
 
 
 
//определение функций
 
//--------------------главная функция
 
void main()
 
{
    setlocale(LC_ALL, "Russian");
 
        //определение координат точек
 
        Point p1(0, 0); Point p2(0.5, 1);
 
        Point p3(1, 0); Point p4(0, 4.5);
 
        Point p5(2, 1); Point p6(2, 0);
 
        Point p7(2, 2); Point p8(3, 0);
 
      //Треугольники
Triangle tr1(p1,p2,p3,"triangleA");
Triangle tr2(p1,p4,p8,"triangleB");
Triangle tr3(p1,p5,p6,"triangleC");
Triangle tr4(p1,p7,p8,"triangleD");
 
 
 
 
//определение массива указателей на треугольники
 
Triangle *ptrTr[]={&tr1, &tr2, &tr3, &tr4};
int n=sizeof(ptrTr)/sizeof(ptrTr[0]);//определяемдлинумассива
 
 
 
 
//Главный цикл
 
        bool done=false;
 
        while (!done) { //выполняется пока 
 
                switch(Menu()) {
    case 1:
            Show(ptrTr,n);
            break;
        case 2:
            Move(ptrTr,n);
            break;
        case 3:
            FindMax(ptrTr,n);
            break;
 
 
                
            case 4:
            done=true;
            break;
        
 
 
                }
 
        }
 
    
 
}
 
//----------------------вывод меню
 
int Menu(){
 
    int vibor=0;
    do{
    cout<<"\n\n==================================Меню========================"<<endl;
    cout<<"1. вывести все обьекты"<<endl;
    cout<<"2. переместить"<<endl;
    cout<<"3. найти максимальный"<<endl;
    cout<<"4. выход"<<endl;
    std::cin>>vibor;
    }while(vibor<1 || vibor>4);
    return vibor;
}
 
 
 
 
 
 
//-----------------вывод всех треугольников
 
void Show(Triangle *ptrTr[], int k){
 
        cout<<"==========Triangles=========="<<std::endl;
 
        for (int i=0; i<k; ++i) ptrTr[i]->Show();//вызов метода Show() для объекта класса Triangle
 
        ExitBack();
 
}
 
//-------------------ввод вещественного числа
 
 
//-----------------перемещение
 
void Move(Triangle* ptrTr[], int k){
    cout<<"\n=======Перемещение========"<<std::endl;
    cout<<"Введите номер треугольника (от 1 до "<<k<<"),который желаете переметить: ";
 
 
        int i=GetNumber(1, k)-1;
 
        ptrTr[i]->Show ();//вызов метода Show() для объекта класса Triangle
 
 
 
        Point dp;
 
        cout<<"Enter smeschenie po x: ";
 
        dp.x =GetDouble();
 
        cout<<"Enter smeschenie po y: ";
 
        dp.y =GetDouble();
 
 
 
        ptrTr[i]->Move (dp);//вызов метода Move() для объекта класса Triangle
 
        cout<<"New place of triangle: "<<std::endl;
 
        ptrTr[i]->Show ();//вызов метода Show() для объекта класса Triangle
 
        ExitBack();
 
}
 
//-----------------поиск максимального треугольника
 
void FindMax(Triangle* p_tria[], int k) {
 
        cout<<"====Find max triangle===="<<endl;
 
        /*Создаем объект TriaMax, который по завершении поиска будет идентичен максимальному объекту
 
        Инициализируем его значением 1-го объекта из массива объектов*/
 
        Triangle triaMax("triaMax");
 
        triaMax=*p_tria[0];
 
        //Поиск
 
        for (int i=1; i<4; ++i)
 
                if (*p_tria[i]>triaMax)
 
                        triaMax=*p_tria[i];
 
                cout<<"Max triangle is: "<<triaMax.GetName()<<endl;
 
        ExitBack();
 
}
 
//конструктор копирования
 
Triangle::Triangle(const Triangle& tria):v1(tria.v1), v2(tria.v2), v3(tria.v3) {
 
        cout<<"Copy constructor for: "<<tria.objID <<std::endl; //отладочный вывод
 
        objID=new char[strlen(tria.objID )+strlen("kopia")+1];//выделяем динамическую память
 
        strcpy(objID, tria.objID ); //копирует строку objID в строку tria.objID
 
        strcat(objID, "(kopia)");       //объединяет строки objID и "(kopia)" в строку objID
 
        
 
        name=new char[strlen(tria.name )+1];//функция strlen возвращает длину строки 
 
        strcpy(name, tria.name );
 
        a=tria.a ;
 
        b=tria.b ;
 
        c=tria.c ;
 
}
 
//показать точку
 
void Point::Show() const {
 
        cout<<" (" <<x<< ", "<<y<< ")";
 
}
 
void Point::operator +=(Point& p) {
 
        x +=p.x ; y +=p.y ;//запуск перегружаемого +=
 
}
 
Point Point::operator + (Point& p) {
 
        return Point(x+p.x, y+p.y);//запуск перегружаемого +
 
}
 
Point Point::operator - (Point& p) {
 
        return Point(x-p.x, y-p.y);//запуск перегружаемого -
 
}
 
double Point::Length () const {
 
        return sqrt(x*x+y*y);
 
}
 
ORIENT Point::Classify (Point& beg_p, Point& end_p) const {
 
        Point p0=*this;
 
        Point a=end_p-beg_p;
 
        Point b=p0-beg_p;
 
        double sa=a.x *b.y - b.x *a.y ;
 
 
 
        if (sa>0.0) return LEFT;
 
        if (sa<0.0) return RIGHT;
 
 
 
        if ((a.x *b.x <0.0) || (a.y*b.y <0.0)) return BEHIND;
 
        if (a.Length ()<b.Length ()) return AHEAD;
 
        
 
        return BETWEEN;
 
}
//оператор-функция, присвоить значение объекта tria
 
Triangle& Triangle::operator=(const Triangle& tria) {
 
        cout<<"Assign operator: "<<objID<<"="<<tria.objID <<endl; //отладочныйы вывод
 
        
 
        if (&tria==this) return *this;
 
        delete[] name;
 
        name=new char[strlen(tria.name)+1];
 
        strcpy(name, tria.name );
 
        a=tria.a ;      b=tria.b ;    c=tria.c ;//запуск перегружаемого =
 
        return *this;
 
}
 
//конструктор
 
Triangle::Triangle(Point _v1, Point _v2, Point _v3, const char* ident): v1 (_v1), v2 (_v2), v3  (_v3) 
 
{
 
        char buf[16];
 
        
 
        objID=new char[strlen(ident)+1];
 
        strcpy(objID, ident);
 
        
 
        count++;//добавить объект
 
        sprintf(buf,"Triangle %d", count);
 
        name=new char[strlen(buf)+1];
 
        strcpy(name, buf);
 
        a=sqrt((v1.x-v2.x)*(v1.x-v2.x)+(v1.y-v2.y)*(v1.y-v2.y));
 
        b=sqrt((v2.x-v3.x)*(v2.x-v3.x)+(v2.y-v3.y)*(v2.y-v3.y));
 
        c=sqrt((v1.x-v3.x)*(v1.x-v3.x)+(v1.y-v3.y)*(v1.y-v3.y));
 
        cout<< "Constructor_1 for: "<<objID<< " (" <<name<< ")" <<endl;//отладочный вывод
 
}
 
//Конструктор пустого (нулевого) треугольника
 
Triangle::Triangle(const char* ident) {
 
        char buf[16];
 
        objID=new char[strlen(ident)+1];
 
        strcpy(objID, ident);
 
        
 
        count++;//добавить объект
 
        sprintf(buf, "Triangle %d", count);//выполняет форматированный вывод в строку
 
        name=new char[strlen(buf)+1];
 
        strcpy(name, buf);
 
        a=b=c=0;
 
        cout<< "Constructor_2 for: "<<objID<<" (" <<name<< ")"<<endl; //отладочный вывод
 
}
 
//оператор-функция, сравнить объект (по площади) с объектом tria
 
bool Triangle::operator > (const Triangle& tria) const {
 
        double p=(a+b+c)/2;
 
        double s=sqrt(p*(p-a)*(p-b)*(p-c));
 
        double p1=(tria.a +tria.b +tria.c )/2;
 
        double s1=sqrt(p1*(p1-tria.a)*(p1-tria.b)*(p1-tria.c));
 
        if (s>s1) return true;//запуск перегружаемого >
 
        else    return false;
 
}
//Деструктор
 
Triangle::~Triangle() {
 
        cout<<"Destructor for: "<<objID<<endl;
 
        delete[] objID;// очистка динамической памяти 
 
        delete[] name;
 
}
 
void Triangle::Show() const {
 
        cout<<name<<":";
 
        v1.Show(); v2.Show(); v3.Show();
 
        cout<<endl;
 
}
 
 
//показать стороны и площадь треугольника
 
void Triangle::Move (Point dp) {
 
        v1 +=dp;        v2 +=dp;        v3 +=dp;
 
}
//-----------------Определение отношения включения
 
bool TriaInTria(Triangle tria1, Triangle tria2) {
 
        Point v1=tria1.Get_v1 ();
 
        Point v2=tria1.Get_v2 ();
 
        Point v3=tria1.Get_v3 ();
 
        return (v1.InTriangle (tria2) && v2.InTriangle (tria2) && v3.InTriangle (tria2));
 
        return true;
 
}
 
class Point {
 
public:
 
                //конструктор с двумя аргументами
 
                Point(double _x=0, double _y=0) : x(_x), y(_y){}// x=_x; y=_y;
 
 
 
                Point operator +(Point&);//оператор-функция перегрузки оператора сложения
 
 
 
                Point operator -(Point&);//оператор-функция перегрузки оператора вычитания
 
 
 
                //определяет длину вектора точки в полярной системе координат
 
                double Length() const;
 
 
 
                //определяет положение точки относительно вектора, заданного двумя точками
 
                ORIENT Classify(Point&, Point&) const;
 
 
 
                //определяет, находится ли точка внутри треугольника
 
                bool InTriangle(Triangle&) const;//объяснить зачем параметр - ссылка???????????????
 
 
 
        void Show() const;
 
 
 
        void operator +=(Point&);//оператор-функция перегрузки оператора сложения с присваиванием
 
//public:
 
        double x,y;
 
};
 
 
 
/////////////////////////////////////
 
 
 
 
 
 
 
 
 
 
class Triangle {
 
public:
 
        bool operator>(const Triangle&) const;//оператор-функция перегрузки оператора сравнения
 
 
 
        Triangle(const Triangle&);// конструктор копирования
 
 
 
        Triangle& operator=(const Triangle&);//оператор-функция перегрузки оператора присваивания
 
 
 
        //дружественная функция, которая определяет, входит ли один треугольник во второй
 
        friend bool TriaInTria(Triangle, Triangle);
 
        
 
        Triangle(Point, Point, Point, const char*);//конструктор
 
        
 
        Triangle(const char*);//конструктор пустого(нулевого) треугольника:использует значение по умолчанию
 
 
 
        ~Triangle(); //деструктор
 
 
 
        Point Get_v1() const { return v1; } //получить значение v1
 
        Point Get_v2() const { return v2; } //получить значение v2
 
        Point Get_v3() const { return v3; } //получить значение v3
 
 
 
        char* GetName() const { return name; } //получить имя объекта
 
 
 
        void Show() const; //показать объект
 
 
 
        void Move(Point);
 
//public:
 
        static int count;//кол-во созданных объектов класса
 
private:
 
        char* objID;//идентификатор объекта
 
        char* name;//наименование треугольника
 
        Point v1, v2, v3;//вершины
 
        double a;//сторона, соединяющая v1 и v2
 
        double b;//сторона, соединяющая v2 и v3
 
        double c;//сторона, соединяющая v1 и v3
 
};

#ifndef POINT_H
 
#define POINT_H
 
 
 
//объявление перечислимой константы ORIENT
 
 
 
enum ORIENT {LEFT,RIGHT,AHEAD,BEHIND,BETWEEN};
 
 
 
//класс Point ссылается на класс Triangle, значит Triangle должен быть объявлен до Point
 
class Triangle;
 
 
 
//создание класса Point
 
class Point {
 
public:
 
                //конструктор с двумя аргументами
 
                Point(double _x=0, double _y=0) : x(_x), y(_y){}// x=_x; y=_y;
 
 
 
                Point operator +(Point&);//оператор-функция перегрузки оператора сложения
 
 
 
                Point operator -(Point&);//оператор-функция перегрузки оператора вычитания
 
 
 
                //определяет длину вектора точки в полярной системе координат
 
                double Length() const;
 
 
 
                //определяет положение точки относительно вектора, заданного двумя точками
 
                ORIENT Classify(Point&, Point&) const;
 
 
 
                //определяет, находится ли точка внутри треугольника
 
                bool InTriangle(Triangle&) const;//объяснить зачем параметр - ссылка???????????????
 
 
 
        void Show() const;
 
 
 
        void operator +=(Point&);//оператор-функция перегрузки оператора сложения с присваиванием
 
//public:
 
        double x,y;
 
};
 
#endif /*POINT_H*/

class Triangle {
 
public:
 
        bool operator>(const Triangle&) const;//оператор-функция перегрузки оператора сравнения
 
 
 
        Triangle(const Triangle&);// конструктор копирования
 
 
 
        Triangle& operator=(const Triangle&);//оператор-функция перегрузки оператора присваивания
 
 
 
        //дружественная функция, которая определяет, входит ли один треугольник во второй
 
        friend bool TriaInTria(Triangle, Triangle);
 
        
 
        
 
        
 
        Triangle(const char*);//конструктор пустого(нулевого) треугольника:использует значение по умолчанию
 
 
 
        ~Triangle(); //деструктор
 
 
 
        
 
 
        char* GetName() const { return name; } //получить имя объекта
 
 
 
        void Show() const; //показать объект
 
 
 
//public:
 
        static int count;//кол-во созданных объектов класса
 
private:
 
        char* objID;//идентификатор объекта
 
        char* name;//наименование треугольника
 
       
 
        double a;//сторона, соединяющая v1 и v2
 
        double b;//сторона, соединяющая v2 и v3
 
        double c;//сторона, соединяющая v1 и v3
 
};

#include <iostream>
 
#include "Triangle.h"
#include"Point.h"
 
using namespace std;
 
 
 
// F U N C T I O N S /////////////////////////////////////////////////////////
 
 
 
//прототипы используемых функций
 
int Menu();
 
int GetNumber(int, int);
 
void ExitBack();
 
void Show(Triangle* [], int);
 
double GetDouble();
 
void Move(Triangle* [], int);
 
void FindMax(Triangle* [], int);
 
void IsIncluded(Triangle* [], int);
 
 
 
//инициализация глобальной переменной
 
int Triangle::count=0;
 
 
 
//определение функций
 
//--------------------главная функция
 
int main()
 
{
 
        //определение координат точек
 
        Point p1(0, 0); Point p2(0.5, 1);
 
        Point p3(1, 0); Point p4(0, 4.5);
 
        Point p5(2, 1); Point p6(2, 0);
 
        Point p7(2, 2); Point p8(3, 0);
 
//определения треугольников
 
        Triangle triaA(p1, p2, p3, "triaA");
 
        Triangle triaB(p1, p4, p8, "triaB");
 
        Triangle triaC(p1, p5, p6, "triaC");
 
        Triangle triaD(p1, p7, p8, "triaD");
 
 
 
//определение массива указателей на треугольники
 
        Triangle* pTria[]={&triaA,&triaB,&triaC,&triaD};
 
        int n=sizeof(pTria)/sizeof(pTria[0]);
 
 
 
//Главный цикл
 
        bool done=false;
 
        while (!done) { //выполняется пока 
 
                switch(Menu()) {
 
                case 1:Show(pTria, n);  break;
 
                case 2:Move(pTria, n);  break;
 
                case 3:FindMax(pTria, n);       break;
 
                case 4:IsIncluded(pTria, n);    break;
 
                case 5:cout<<"End."<<endl;
 
                        done=true; break;
 
                }
 
        }
 
        return 0;
 
}
 
//----------------------вывод меню
 
int Menu()
 
{
 
        cout<<"n============M A I N   M E N U=========="<<endl;
 
        cout<<"1 - Show all objectst 3 - Find max"<<endl;
 
        cout<<"2 - Movett 4 - Is included in"<<endl;
 
        cout<<"tt5 - Exit"<<endl;
 
        return GetNumber(1, 5);
 
}
 
//-------------вывод целого числа в заданном диапазоне
 
int GetNumber(int min, int max) {
 
        int number=min-1;
 
        while (true) {
 
                cin>>number;
 
                if ((number>=min) && (number<=max) && (cin.peek()=='n') )
 
                        break;
 
                else {
 
                        cout<<"Retry (number must be from "<<min<<" till "<<max<<"):"<<endl;
 
                        cin.clear();//очистить биты ошибок
 
                        while (cin.get() !='n'){}// cin.get извлекает один символ
 
                }
 
        }
 
        return number;
 
}
 
//-----------------возврат в функцию с основным меню
 
void ExitBack() {
 
        cout<<"Push Enter."<<endl;
 
        cin.get (); cin.get ();
 
}
 
//-----------------вывод всех треугольников
 
void Show(Triangle* p_tria[], int k) {
 
        cout<<"==========Triangles=========="<<endl;
 
        for (int i=0; i<k; ++i) p_tria[i]->Show();//вызов метода Show() для объекта класса Triangle
 
        ExitBack();
 
}
 
//-------------------ввод вещественного числа
 
double GetDouble()
 
{
 
        double value;
 
        while (true) {
 
                cin>>value;
 
                if (cin.peek ()=='n') break;//cin.peek читает один символ, оставляя его в потоке
 
                else {
 
                        cout<<"Retry (number must be ves4estvennoe):"<<endl;
 
                        cin.clear ();
 
                        while (cin.get ()!='n') {};
 
                }
 
        }
 
        return value;
 
}
 
//-----------------перемещение
 
void Move(Triangle* p_tria[], int k) {
 
        cout<<"==========Move============"<<endl;
 
        cout<<"Enter number of triangle (from 1 till "<<k<<"): ";
 
        int i=GetNumber(1, k)-1;
 
        p_tria[i]->Show ();//вызов метода Show() для объекта класса Triangle
 
 
        cout<<"New place of triangle: "<<endl;
 
        p_tria[i]->Show ();//вызов метода Show() для объекта класса Triangle
 
        ExitBack();
 
}
 
//-----------------поиск максимального треугольника
 
void FindMax(Triangle* p_tria[], int k) {
 
        cout<<"====Find max triangle===="<<endl;
 
        /*Создаем объект TriaMax, который по завершении поиска будет идентичен максимальному объекту
 
        Инициализируем его значением 1-го объекта из массива объектов*/
 
        Triangle triaMax("triaMax");
 
        triaMax=*p_tria[0];
 
        //Поиск
 
        for (int i=1; i<4; ++i)
 
                if (*p_tria[i]>triaMax)
 
                        triaMax=*p_tria[i];
 
                cout<<"Max triangle is: "<<triaMax.GetName()<<endl;
 
        ExitBack();
 
}
 
//-----------------Определение отношения включения
 
void IsIncluded(Triangle* p_tria[], int k) {
 
        cout<<"====Opredelit' otnoshenie vklu4enia===="<<endl;
 
        cout<<"Enter number of the first triangle (from 1 till "<<k<<"): ";
 
        int i1=GetNumber(1,k)-1;
 
 
 
        cout<<"Enter number of the second triangle (from 1 till "<<k<<"): ";
 
        int i2=GetNumber(1,k)-1;
 
 
 
        if (TriaInTria(*p_tria[i1], *p_tria[i2]))//вызов дружественной функции
 
                //вызываем метод GetName() для объекта класса Triangle, на который указывает указатель,
 
                //являющийся i1 и i2 элементом соответственно массива p_tria
 
                cout<<p_tria[i1]->GetName ()<<" - is included in - "<<p_tria[i2]->GetName ()<<endl;
 
        else 
 
                cout<<p_tria[i1]->GetName ()<<"is not included in - "<<p_tria[i2]->GetName ()<<endl;
 
        ExitBack();
 
}

#include <math.h> //для sqrt
 
#include <iostream>
 
#include <iomanip> 
#include"Point.h"
 
#include <cstring>//для strlen, strcat, strcpy
 
#include "Triangle.h"
 
//using namespace std;
 
 
 
// F U N C T I O N S /////////////////////////////////////////////////////////
 
 
 
//конструктор копирования
 
Triangle::Triangle(const Triangle& tria):v1(tria.v1), v2(tria.v2), v3(tria.v3) {
 
        cout<<"Copy constructor for: "<<tria.objID <<std::endl; //отладочный вывод
 
        objID=new char[strlen(tria.objID )+strlen("kopia")+1];//выделяем динамическую память
 
        strcpy(objID, tria.objID ); //копирует строку objID в строку tria.objID
 
        strcat(objID, "(kopia)");       //объединяет строки objID и "(kopia)" в строку objID
 
        
 
        name=new char[strlen(tria.name )+1];//функция strlen возвращает длину строки 
 
        strcpy(name, tria.name );
 
        a=tria.a ;
 
        b=tria.b ;
 
        c=tria.c ;
 
}
 
 
 
//оператор-функция, присвоить значение объекта tria
 
Triangle& Triangle::operator=(const Triangle& tria) {
 
        cout<<"Assign operator: "<<objID<<"="<<tria.objID <<std::endl; //отладочныйы вывод
 
        
 
        if (&tria==this) return *this;
 
        delete[] name;
 
        name=new char[strlen(tria.name)+1];
 
        strcpy(name, tria.name );
 
        a=tria.a ;      b=tria.b ;    c=tria.c ;//запуск перегружаемого =
 
        return *this;
 
}
 
 
 
//конструктор
 
Triangle::Triangle(Point _v1, Point _v2, Point _v3, const char* ident): v1 (_v1), v2 (_v2), v3  (_v3) 
 
{
    
 
        char buf[16];
 
        
 
        objID=new char[strlen(ident)+1];
 
        strcpy(objID, ident);
 
        
 
        count++;//добавить объект
 
        sprintf(buf,"Triangle %d", count);
 
        name=new char[strlen(buf)+1];
 
        strcpy(name, buf);
 
        a=sqrt((v1.x-v2.x)*(v1.x-v2.x)+(v1.y-v2.y)*(v1.y-v2.y));
 
        b=sqrt((v2.x-v3.x)*(v2.x-v3.x)+(v2.y-v3.y)*(v2.y-v3.y));
 
        c=sqrt((v1.x-v3.x)*(v1.x-v3.x)+(v1.y-v3.y)*(v1.y-v3.y));
 
       std::cout<< "Constructor_1 for: "<<objID<< " (" <<name<< ")" <<std::endl;//отладочный вывод
 
}
 
 
 
//Конструктор пустого (нулевого) треугольника
 
Triangle::Triangle(const char* ident) {
 
        char buf[16];
 
        objID=new char[strlen(ident)+1];
 
        strcpy(objID, ident);
 
        
 
        count++;//добавить объект
 
        sprintf(buf, "Triangle %d", count);//выполняет форматированный вывод в строку
 
        name=new char[strlen(buf)+1];
 
        strcpy(name, buf);
 
        a=b=c=0;
 
        cout<< "Constructor_2 for: "<<objID<<" (" <<name<< ")"<<endl; //отладочный вывод
 
}
 
 
 
//оператор-функция, сравнить объект (по площади) с объектом tria
 
bool Triangle::operator > (const Triangle& tria) const {
 
        double p=(a+b+c)/2;
 
        double s=sqrt(p*(p-a)*(p-b)*(p-c));
 
        double p1=(tria.a +tria.b +tria.c )/2;
 
        double s1=sqrt(p1*(p1-tria.a)*(p1-tria.b)*(p1-tria.c));
 
        if (s>s1) return true;//запуск перегружаемого >
 
        else    
            
            return false;
 
}
 
//Деструктор
 
Triangle::~Triangle() {
 
        std::cout<<"Destructor for: "<<objID<<std::endl;
 
        delete[] objID;// очистка динамической памяти 
 
        delete[] name;
 
}
 
 
 
//показать треугольник
 
void Triangle::Show() const {
 
        cout<<name<<":";
 
        v1.Show(); v2.Show(); v3.Show();
 
        cout<<std::endl;
 
}
 
 
 
//показать стороны и площадь треугольника
 
void Triangle::Move (Point dp) {
 
        v1 +=dp;        v2 +=dp;        v3 +=dp;
 
}
 
 
 
//определить, входит ли треугольник tria1 в треугольник tria2
 
bool TriaInTria(Triangle tria1, Triangle tria2) {
 
        Point v1=tria1.Get_v1 ();
 
        Point v2=tria1.Get_v2 ();
 
        Point v3=tria1.Get_v3 ();
 
        return (v1.InTriangle (tria2) && v2.InTriangle (tria2) && v3.InTriangle (tria2));
 
        return true;
 
}