производный класс

//point.h
#ifndef POINT_H
#define POINT_H
class Triangle;
class Pentagon;
enum ORIENT { LEFT, RIGHT, AHEAD, BEHIND, BETWEEN };
class Point
{
public:
    Point (double x1=0, double y1=0): x(x1),y(y1){}
    void Show() const;
    void operator +=(Point&);
    
    ORIENT Or(Point &, Point &) const;
    Point operator + (Point &);
    Point operator - (Point &);
    double Length() const;
    bool InTr(Triangle &) const;
public:
    double x,y;
};
#endif
//point.cpp
#include <iostream>
#include <math.h>
#include "Point.h"
#include "Triangle.h"
using namespace std;
void Point::Show()const
{
    cout<<x<<";"<<y;
}
void Point::operator +=(Point& p) 
{
    x = x + p.x; 
    y = 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::Or(Point& b, Point& e) const 
{
    Point p0 = *this; 
    Point a = e - b;
    Point c = p0 - b;
    double s = a.x * b.y - b.x * a.y;
    if (s < 0) return RIGHT;
    if (s > 0) return LEFT;
    if ((a.x * c.x < 0) || (a.y * c.y < 0)) return BEHIND;
    if (a.Length() > c.Length()) 
        return BETWEEN;
    return AHEAD;
}
bool Point::InTr(Triangle& T) const 
{
ORIENT or1 = Or(T.Get_v1(), T.Get_v2());
ORIENT or2 = Or(T.Get_v2(), T.Get_v3());
ORIENT or3 = Or(T.Get_v3(), T.Get_v1());
if ((or1 == RIGHT || or1 == BETWEEN)
 && (or2 == RIGHT || or2 == BETWEEN)
 && (or3 == RIGHT || or3 == BETWEEN)) 
return 1;
else return 0;
}
//Triangle.h
#ifndef TR_H
#define TR_H
#include "Point.h"
class Triangle
{
private:
    char* objID;
    char* name;
    Point v1,v2,v3;
    double a,b,c;
public:
    Triangle(Point, Point, Point, const char*);
    Triangle(const char*);
    Triangle(const Triangle&);
    Triangle &operator =(const Triangle&);
    ~Triangle();
    Point Get_v1() const { return v1; }
    Point Get_v2() const { return v2; }
    Point Get_v3() const { return v3; }
    char *GetName() const { return name; }
    void Show() const;
    void ShowSideAndArea() const;
    void Move(Point);
    bool operator >(const Triangle&) const;
    static int count;
    friend bool TrInTr(Triangle, Triangle); 
};
#endif;
//Triangle.cpp
#include <iostream>
#include <math.h>
#include <iomanip>
#include <cstring>
#include "Triangle.h"
using namespace std;
Triangle::Triangle(Point w1, Point w2, Point w3, const char*iden): v1(w1), v2(w2), v3(w3)
{
    char buf[20];
    objID = new char [strlen(iden)+1];
    strcpy(objID, iden);
    count++;
    sprintf(buf, "triangle %d", count);
    name=new char[strlen(buf)+1];
    strcpy(name, buf); 
    a=sqrt((w1.x-w2.x)*(w1.x-w2.x)+(w1.y-w2.y)*(w1.y-w2.y));
    b=sqrt((w2.x-w3.x)*(w2.x-w3.x)+(w2.y-w3.y)*(w2.y-w3.y));    
    c=sqrt((w1.x-w3.x)*(w1.x-w3.x)+(w1.y-w3.y)*(w1.y-w3.y));
    cout << "constructor 1 for: " << objID << "(" << name << ")" << endl;
}
Triangle::Triangle(const char*iden)
{   
    char buf[20];
    objID = new char [strlen(iden)+1];
    strcpy(objID, iden);
    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;
}
Triangle::~Triangle()
{
    cout << "Destructor for: " << objID << endl;
    delete []objID;
    delete []name;
}
void Triangle::Show() const
{ 
    v1.Show();
    cout<< endl;
    v2.Show();
    cout<< endl;
    v3.Show();
    cout<< endl;
}
void  Triangle::ShowSideAndArea() const
{
    double p =(a + b + c) / 2;
    double S = sqrt(p * (p - a) * (p - b) * (p - c));
    cout << name << ':';
    cout.precision (4);
    cout << setw(10) << a;
    cout << setw(10) << b;
    cout << setw(10) << c;
    cout << endl << "size" << S <<endl;
}
void Triangle::Move(Point p) 
{
    v1 += p; 
    v2 += p; 
    v3 += p;
}
bool Triangle::operator >(const Triangle& T) const 
{
    double p = (a + b + c) / 2;
    double s = sqrt(p * (p - a) * (p - b) * (p - c));
    double pT = (T.a + T.b + T.c) / 2;
    double sT = sqrt(pT * (pT - T.a) * (pT - T.b) * (pT - T.c));
    if (s > sT) 
        return true;
    return false;
}
Triangle::Triangle(const Triangle& T):
v1(T.v1), v2(T.v2), v3(T.v3), a(T.a), b(T.b), c(T.c) 
{
    cout << "Copy constructor for: " << T.objID << " ( " << T.name << " ) " << endl; 
    objID = new char[strlen(T.objID) + strlen("(.copy)") + 1];
    strcpy(objID, T.objID);
    strcat(objID, ".copy");
    name = new char[strlen(T.name) + 1];
    strcpy(name,  T.name);
}
Triangle& Triangle::operator =(const Triangle& T) 
{
    cout << "Operator =: " << objID << " = " << T.objID << endl;
    if (&T == this) 
        return *this;
    delete [] name;
    name = new char[strlen(T.name) + 1];
    strcpy(name, T.name);
    a = T.a; 
    b = T.b; 
    c = T.c;
    return *this;
}
bool TrInTr(Triangle T1, Triangle T2) 
{
    Point v1 = T1.Get_v1();
    Point v2 = T1.Get_v2();
    Point v3 = T1.Get_v3();
    return (v1.InTr(T2) && v2.InTr(T2) && v3.InTr(T2));
    return true;
}
#ifndef PENTAGON_H
#define PENTAGON_H
#include "Point.h"
#include "Triangle.h"
class Pentagon: public Triangle
{
private:
    char* objIDP;
    char* Pname;
    Point v1,v2,v3,v4,v5;
    double a,b,c,d,e,dop1,dop2;
public:
    Pentagon(Point, Point, Point, Point, Point, const char*);
    Pentagon(const char*);
    Pentagon(const Pentagon&);
//    ~Pentagon();
    Point Get_v1() { return v1; };
    Point Get_v2() { return v2; };
    Point Get_v3() { return v3; };
    Point Get_v4() { return v4; );
    Point Get_v5() { return v5; };
    char* GetName();
    void Show() const;
//    void ShowSideAndArea() const;
    void Move(Point);
    bool operator >(const Pentagon&) const;
    static int count;
    Pentagon &operator =(const Pentagon&);
};
#endif;
//Pentagon.cpp
#include <iostream>
#include <math.h>
#include <iomanip>
#include <cstring>
#include "Pentagon.h"
#include "Point.h"
using namespace std;
Pentagon::Pentagon(Point w1, Point w2, Point w3, Point w4, Point w5, const char* iden):
Triangle(w1, w2, w3, iden), v1(w1), v2(w2), v3(w3), v4(w4), v5(w5) 
{
    char buf[20];
    objIDP = new char [strlen(iden)+1];
    strcpy(objIDP, iden);
    count++;
    sprintf(buf, "pentagon %d", count);
    Pname=new char[strlen(buf)+1];
    strcpy(Pname, buf); 
    a = sqrt((w1.x-w2.x)*(w1.x-w2.x)+(w1.y-w2.y)*(w1.y-w2.y));
    b = sqrt((w3.x-w4.x)*(w3.x-w4.x)+(w3.y-w4.y)*(w3.y-w4.y));    
    c = sqrt((w1.x-w3.x)*(w1.x-w3.x)+(w1.y-w3.y)*(w1.y-w3.y));
    d = sqrt((w4.x-w5.x)*(w4.x-w5.x)+(w4.y-w5.y)*(w4.y-w5.y));
    e = sqrt((w4.x-w5.x)*(w4.x-w5.x)+(w4.y-w5.y)*(w4.y-w5.y));
    dop1 = sqrt((w2.x-w3.x)*(w2.x-w3.x)+(w2.y-w3.y)*(w2.y-w3.y));
    dop2 = sqrt((w2.x-w4.x)*(w2.x-w4.x)+(w2.y-w4.y)*(w2.y-w4.y));
    cout << "constructor 1 for: " << objIDP << "(" << Pname << ")" << endl;
}
Pentagon::Pentagon(const char* iden): Triangle(iden)
{   
    char buf[20];
    objIDP = new char [strlen(iden)+1];
    strcpy(objIDP, iden);
    count++;
    sprintf(buf, "pentagon %d", count);
    Pname = new char[strlen(buf)+1];
    strcpy(Pname, buf); 
    a = b = c = d = e = 0;
    cout << "constructor 2 for: " << objIDP << "(" << Pname << ")" << endl;
}
//Pentagon::~Pentagon()
//{
//    cout << "Destructor for: " << objIDP << endl;
//    delete []objIDP;
//    delete []Pname;
//}
void Pentagon::Show() const
{ 
    Triangle::Show();
    v4.Show();
    cout << endl;
    v5.Show();
    cout << endl;
}
void Pentagon::Move(Point p) 
{
    Triangle::Move(p);
    v4 += p;
    v5 += p;
}
bool Pentagon::operator >(const Pentagon& P) const 
{
    double p1 = (a + b + dop1) / 2;
    double s1 = sqrt(p1 * (p1 - a) * (p1 - b) * (p1 - dop1));
    double pPt1 = (P.a + P.b + P.dop1) / 2;
    double sPt1 = sqrt(pPt1 * (pPt1 - P.a) * (pPt1 - P.b) * (pPt1 - P.dop1));
    double p2 = (dop2 + c + dop1) / 2;
    double s2 = sqrt(p2 * (p2 - dop2) * (p2 - c) * (p2 - dop1));
    double pPt2 = (P.dop2 + P.c + P.dop1) / 2;
    double sPt2 = sqrt(pPt2 * (pPt2 - P.dop2) * (pPt2 - P.c) * (pPt2 - P.dop1));
    double p3 = (dop2 + d + e) / 2;
    double s3 = sqrt(p3 * (p3 - dop2) * (p3 - d) * (p3 - e));
    double pPt3 = (P.dop2 + P.d + P.e) / 2;
    double sPt3 = sqrt(pPt3 * (pPt3 - P.dop2) * (pPt3 - P.d) * (pPt3 - P.e));
    double sumP1, sumP2;
    sumP1 = s1 + s2 + s3;
    sumP2 = sPt1 + sPt2 + sPt3;
    
    if (sumP1 > sumP2) 
        return true;
    return false;
}
Pentagon Pentagon::operator = (const Pentagon& P) 
{
    cout << "Operator =: " << objIDP << " = " << P.objIDP << endl;
    if (&P == this) 
        return *this;
    delete [] Pname;
    Pname = new char[strlen(P.Pname) + 1];
    strcpy(Pname, P.Pname);
    a = P.a; 
    b = P.b; 
    c = P.c;
    d = P.d;
    e = P.e;
    dop1 = P.dop1;
    dop2 = P.dop2;
    return *this;
}
// Main.cpp
#include <iostream>
#include "Pentagon.h"
#include "Triangle.h"
using namespace std;
double GetDouble();
int Menu();
int GetNumber(int min, int max);
void ExitBack();
void FindMax(Pentagon*[], int n);
void Show(Pentagon*[], int n);
void Move(Pentagon*[], int n);
//void IsIncluded(Triangle*[], int n);
int Pentagon::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);
    Pentagon PentA(p1,p2,p3,p4,p5, "PentA");
    Pentagon PentB(p4,p5,p6,p7,p8, "PentB");
 /*   Triangle PentC(p1,p5,p6, "TriC");
    Triangle PentD(p1,p7,p8, "TriD");*/
    Triangle *pPent[] = {&PentA, &PentB};
    int n = sizeof (pPent) / sizeof (pPent[0]);
    bool done = false;
    while (!done)
    {
        switch (Menu())
        {
            case 1: FindMax(pPent, n); break;
            case 2: Show(pPent, n); break;
            case 3: Move(pPent, n); break;
            case 4: cout << "End" << endl;
            done=true; break;
        }
   }
   return 0;
}
double GetDouble() 
{
    double v;
    while (true) 
    {
        cin >> v;
        if (cin.peek() == '\n') 
            break;
        else
        {
            cin.clear();
            cout << "Wrong input" << endl;
            while (cin.get() != '\n') {};
        }
    }
    return v;
}
int Menu()
{ cout << "------------Menu------------";
  cout<<endl;
  cout<<"FindMax -1"
  <<"\t Move -3"<<endl;
  cout<<"Show -2"
  <<"\t End -4"<<endl;
  return GetNumber (1,4);
}
int GetNumber (int min, int max)
{ int n = min - 1;
  while (true)
  { 
      cin >> n;
      if ((n >= min) && (n <= max))
        break;
      else 
      {
          cout << "Try again!!!" << endl;
      cin.clear(); 
      }
  }
  return n;
}
 
void ExitBack()
{    
    cout << "Press Enter " << endl;
    cin.get(); // \0
    cin.get(); // \n
}
 
void Show(Pentagon *pPent[], int n)
{
    int i;
    cout << "----------Show----------" << endl;
    for (i = 0; i<n; i++)
    {
        pPent[i] -> Show();
 //       pTria[i] -> ShowSideAndArea();
    }
    ExitBack();
}
 
void Move(Pentagon *pPent[], int n)
{
    cout << "----------Move----------" << endl;
    cout << "Enter number of triangle: ";
    int i = GetNumber(1, n) - 1;
    pPent[i]->Show();
    Point p;
    cout << "X-move \n";
    p.x = GetDouble();
    cout << "Y-move \n";
    p.y = GetDouble();
    pPent[i]->Move(p);
    cout << "New position \n";
    pPent[i]->Show();
    ExitBack();
}
void FindMax(Pentagon *pPent[], int n)
{
    cout << "----------FindMax----------" << endl;
    Pentagon pMax("tMax");
    pMax = *pPent[0];
    for (int i = 0; i < n; i++)
        if (*pPent[i] > tMax)
            pMax = *pPent[i];
    cout << "Maximal pentagon: " << pMax.GetName() << endl;
    ExitBack();
}

Point Get_v1() { return v1; };
    Point Get_v2() { return v2; };
    Point Get_v3() { return v3; };
    Point Get_v4() { return v4; ); <-- Здесь скобка не та
    Point Get_v5() { return v5; };