Базовый класс "многоугольник" и производные классы "треугольник" и "прямоугольник"

class Point
{
double x, y;
};
 
class Mnogougolnik
{
public:
int Points;  //Число точек многоугольника
Point *Vertexes;  //Динамический массив вершин много угольника
 
//Конструктор
Mnogougolnik(void)
{
    cout << "Vvedite kolichestvo tochek monogougolnika.";
    cin >> Points;
    Point Vertexes = new Point[Points];
    //Тут нужно заполнить этот массив с консоли или еще откуда-нибудь
}
 
//Деструктор
~Mnogougolnik(void)
{
    delete[] Vertexes;
}
};
 
//Идем дальше, наследуем от Многоугольника классы Треугольник и Прямоугольник
class Triangle: Mnogougolnik: Points(3)  //Так или не так инициализировать переменные, не помню уже:)
{
//Ну и все. Тут будет конструктор с вводом 3-х точек из консоли и все.
}
 
class Rectangle: Mnogougolnik: Points(2) 
{
//А тут будет конструктор с вводом 2-х точек из консоли.
}

Point *Vertexes = new Point[Points];

//Конструктор
Mnogougolnik(void)
{
    cout << "Vvedite kolichestvo tochek monogougolnika.";
    cin >> Points;
    Vertexes = new TPoint[Points];
    
    for(z = 0; z < Points; z++)
    {
        cout << "\nVvedite " << z+1 << " tochku mnogougolnika: x=";
        cin >> Vertexes[z].x;
        cout << "\ny=";
        cin >> Vertexes[z].y;
    }
}

//---------------------------------------------------------------------------
#include <vcl>
#include <iostream>
#include <conio>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
using namespace std;
int z;
 
/*
struct Point
{
double x, y;
};
*/
//Тут заменил на TPoint, который стандартный в C++Builder 6.
 
class Mnogougolnik
{
public:
int Points;  //Число точек многоугольника
TPoint *Vertexes;  //Динамический массив вершин многоугольника
 
//Конструктор
Mnogougolnik(int vp, bool zv/*Zadayetsia Vnutri*/)
{
    cout << "Konstructor: Mnogougolnik.\n";
    if(zv)
    {
        cout << "\nVvedite kolichestvo tochek monogougolnika.";
        cin >> Points;
    }
    else
    {
        vp = Points;
    }
    Vertexes = new TPoint[Points];
 
    //Заполнение массива вершин с консоли
    for(z = 0; z < Points; z++)
    {
        cout << "\nVvedite " << z+1 << " tochku mnogougolnika: x=";
        cin >> Vertexes[z].x;
        cout << "\ny=";
        cin >> Vertexes[z].y;
    }
}
 
//Деструктор
~Mnogougolnik(void)
{
    delete[] Vertexes;
}
};
 
//Классы-наследники Triangle и NRectangle
class Triangle: Mnogougolnik  
{
public:
Triangle(void): Mnogougolnik(3, false)
{
    /*
    cout << "\n\nKonstructor: Triangle.\nVvedite koordinati 3 tochek:";
    for(z = 0; z < Points; z++)
    {
        cout << "\nVvedite " << z+1 << " tochku mnogougolnika: x=";
        cin >> Vertexes[z].x;
        cout << "\ny=";
        cin >> Vertexes[z].y;
    }
    */
}
~Triangle(void)
{}
};
 
class NRectangle: Mnogougolnik
{
public:
NRectangle(void): Mnogougolnik(2, false)
{
    /*
    cout << "\n\nKonstructor: NRectangle.\nVvedite koordinati 2 tochek:";
    for(z = 0; z < Points; z++)
    {
        cout << "\nVvedite " << z+1 << " tochku mnogougolnika: x=";
        cin >> Vertexes[z].x;
        cout << "\ny=";
        cin >> Vertexes[z].y;
    }
    */
}
~NRectangle(void)
{}
};
 
 
Mnogougolnik M1(0, true);
Triangle T1;
NRectangle R1;
 
int main(int argc, char* argv[])
{
getch();
return 0;
}
//---------------------------------------------------------------------------

#include <iostream>
#include <string>
#include "windows.h"
using namespace std;
// Определение базового класса 
class Mnogougolnik {
char color[30];
int status; 
 
public:
Mnogougolnik(){
 strcpy(color,"");
 status=3;
}
char * GetColor()   
{return color;}
int GetStatus()      
{return status;}
void SetColor(char* COLOR)        
{strcpy(color,COLOR);}      
void SetStatus(int STATUS)      
{ if (STATUS==3 || STATUS==4)
     status=STATUS;}
string ShowStatus(int status)  
{ if (status==3)
return "Треугольник";
else return "Прямоугольник";
}
void Show()   //выводит значения всех полей
{cout<<"Многоугольник - > "<<" Цвет: "<<color<<" Количество сторон: "<<status << " Следовательно это - " <<ShowStatus(status)<<"\n";}
};
                
// Определение производного класса 
class TREUGOLNIK : public Mnogougolnik {
int a,b,c,h,s,p;  
public:
STUDENT()   //конструктор без параметров
{
 a=0;
 c=0;
 b=0;
 h=0;
 s=0;
 p=0;
}
 
int GetA()        
{return a;}
int GetB()        
{return b;}
int GetC()       
{return c;}
int GetH()       
{return h;}
void set_a(int A)         
        { a=A;}
void set_b(int B)         
        { b=B;}
void set_c(int C)         
        { c=C;}
void set_h(int H)         
        { h=H;}
        
        
void set_S()              
          {s = (a*h)/2;}
    double Get_S()                
          {return s;}  
void set_P()              
          {p = a+b+c;}
    double Get_P()                
          {return p;}           
          
 
void Show()   //выводит значения всех полей
{cout<<"Многоугольник - > "<<" Цвет: "<< GetColor() <<" Количество сторон: "<<GetStatus() << "\n";
cout<< "Периметр треугольника: " << Get_P() << " Площадь треугольника: " << Get_S() <<"\n";}
 
};
 
class PRYAMOUGOLNIK : public Mnogougolnik{
int a1,b1,p1,s1;
public:
PUPIL()   //конструктор без параметров
{
 a1=0;
 b1=0;
 s1=0;
 p1=0;
}
 
int GetA1()        
{return a1;}
int GetB1()        
{return b1;}
 
void set_a1(int A1)         
        { a1=A1;}
void set_b1(int B1)         
        { b1=B1;}
        
void set_S1()              
          {s1 = a1*b1;}
    double Get_S1()                
          {return s1;}  
void set_P1()              
          {p1 = (a1+b1)*2;}
    double Get_P1()                
          {return p1;}          
          
          
void Show()   //выводит значения всех полей
{cout<<"Многоугольник - > "<<" Цвет: "<< GetColor() <<" Количество сторон: "<<GetStatus() << "\n";
cout<< "Периметр прямоугольника: " << Get_P1() << " Площадь прямоугольника: " << Get_S1() <<"\n";}
};
 
int main (){
 SetConsoleOutputCP(1251);
 SetConsoleCP(1251);
 Mnogougolnik group;
 TREUGOLNIK group1;
 PRYAMOUGOLNIK   group2;
 char color[30];
 int status;
 int a,b,c,h,s,p;
 int a1,b1,p1,s1;
 
 
// базовый класс
  cout<<"Какого цвета многоугольник?  "<<"\n";
  cin>>color;
  group.SetColor(color);
  cout<<"Введите количество сторон:  "<<"\n";
  cin>>status;
  group.SetStatus(status);
cout<<"Данные объектов базового класса:\n";
group.Show();
 
 // наследуемый класс
 
    if (group.GetStatus()==3) {
         group1.SetColor(group.GetColor());    
         cout<<"Введите стороны треугольника\n";
         cout<<"Введите a:\n";
         cin>>a;
         cout<<"Введите b:\n";
         cin>>b;
         cout<<"Введите c:\n";
         cin>>c;
         cout<<"Введите h:\n";
         cin>>h;
         group1.set_S(s);
         group1.set_P(p);
      }
    else {
         group2.SetColor(group.GetColor());
         cout<<"Введите стороны прямоугольника\n";
         cout<<"Введите a:\n";
         cin>>a;
         cout<<"Введите b:\n";
         cin>>b;
         group2.Set_P1(p);
         group2.Set_S1(s);
    }
  
//вывод данных объектов производных классов
cout<<"Данные объектов производных классов:\n";
    group1.Show();
    group2.Show();
system("pause");
 
return 0; }

group1.set_S(s);

STUDENT()

TREUGOLNIK()

PUPIL()

PRYAMOUGOLNIK()

group2.Set_P1(p);
group2.Set_S1(s);

#include <iostream>
#include <string>
#include <cmath>
#include <windows.h>
using namespace std;
// Определение базового класса 
class Mnogougolnik {
protected:
    string color;
    int status; 
public:
    Mnogougolnik():color("black"),status(0){}
    Mnogougolnik(string c,int s):color(c),status(s){}
    //string GetColor(){ return color; }
    //int GetStatus(){ return status; }
    //void SetColor(string COLOR){ color=COLOR; }      
    //void SetStatus(int STATUS){ status=STATUS; }
    virtual string StatusName(){ return "Unknown"; } 
    void Show()   //выводит значения всех полей
    {
        cout<<"Многоугольник - >"<<StatusName()<<" Цвет: "<< color <<" Количество сторон: "<<status << "\n";
        cout<< "Периметр: " << Get_P() << " Площадь: " << Get_S() <<"\n";
    }
    virtual double Get_P(){return 0;}
    virtual double Get_S(){return 0;}
 
};
 
// Определение производного класса 
class TREUGOLNIK : public Mnogougolnik {
    double a,b,c;  
public:
    string StatusName()  
    { return "Треугольник";}
    TREUGOLNIK():Mnogougolnik()   //конструктор без параметров
    {
        a=0;
        c=0;
        b=0;
    }
    TREUGOLNIK(string s,double A,double B,double C):Mnogougolnik(s,3) 
    {
        a=A;
        c=C;
        b=B;
    }
 
    double Get_S()              
    {
        double p=(a+b+c)/2.;
        return sqrt(p*(p-a)*(p-b)*(p-c));
    }
    double Get_P()                
    {
        return a+b+c;
    }           
};
 
class PRYAMOUGOLNIK : public Mnogougolnik{
    double a,b;
public:
    string StatusName()  
    { return "Прямоугольник";}
    PRYAMOUGOLNIK():Mnogougolnik()   //конструктор без параметров
    {
        a=0;
        b=0;
    }
    PRYAMOUGOLNIK(string s,double A,double B):Mnogougolnik(s,4) 
    {
        a=A;
        b=B;
    }
 
    double Get_S()                
    {
        return a*b;
    }  
    double Get_P()                
    {
        return (a+b)*2.0;
    }          
};
 
int main (){
    SetConsoleOutputCP(1251);
    SetConsoleCP(1251);
    Mnogougolnik* pm;
    string color; 
    int status; 
    // базовый класс
    cout<<"Какого цвета многоугольник?  "<<"\n";
    cin>>color;
    cout<<"Введите количество сторон:  "<<"\n";
    cin>>status;
    cout<<"Данные объектов базового класса:\n";
    Mnogougolnik group(color,status);
    pm=&group;
    pm->Show();
 
    // наследуемый класс
    double a,b,c;
    cout<<"Какого цвета треугольник?  "<<"\n";
    cin>>color;
    cout<<"Введите стороны треугольника\n";
    cout<<"Введите a:\n";
    cin>>a;
    cout<<"Введите b:\n";
    cin>>b;
    cout<<"Введите c:\n";
    cin>>c;
    TREUGOLNIK group1(color,a,b,c);
    pm=&group1;
    pm->Show();
 
    // наследуемый класс
    cout<<"Какого цвета прямоугольник?  "<<"\n";
    cin>>color;
    cout<<"Введите стороны прямоугольника\n";
    cout<<"Введите a:\n";
    cin>>a;
    cout<<"Введите b:\n";
    cin>>b;
    PRYAMOUGOLNIK group2(color,a,b);
    pm=&group2;
    pm->Show();
    system("pause");
 
    return 0; 
}

//---------------------------------------------------------------------------
#include <vcl>
#include <iostream>
#include <conio>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
using namespace std;
int z;
 
/*
struct Point
{
double x, y;
};
TPoint
*/
 
class Mnogougolnik
{
public:
int Points;  //×èñëî òî÷åê ìíîãîóãîëüíèêà
TPoint *Vertexes;  //Äèíàìè÷åñêèé ìàññèâ âåðøèí ìíîãîóãîëüíèêà
 
Mnogougolnik(int KV/*Kolichestvo vershin*/,
             TPoint *IA)
{
Points = KV;
Vertexes = IA;
}
 
~Mnogougolnik(void)
{
    delete[] Vertexes;
}
};
//=======================Mnogougolnik========================================
 
 
class Triangle:public Mnogougolnik  
{
public:
Triangle(TPoint *VU): Mnogougolnik(3, VU)
{
}
~Triangle(void)
{}
};
 
class NRectangle:public Mnogougolnik
{
public:
NRectangle(TPoint *VU): Mnogougolnik(2, VU)
{}
~NRectangle(void)
{}
};
 
 
int main(int argc, char* argv[])
{
int V;
TPoint *Massiv;
//===========================Mnogougolnik====================================
cout << "Konstruiruem Mnogoulnik. Vvdedite kolichestvo vershin:";
cin >> V;
 
Massiv = new TPoint[V];
cout << "\nNabivaem vremennii Massiv vershinami.\n\n";
cout << "Vvedite koordinati " << V << " tochek:";
for(z = 0; z < V; z++)
{
    cout << "\nVvedite " << z+1 << " tochku mnogougolnika:\nx=";
    cin >> Massiv[z].x;
    cout << "\ny=";
    cin >> Massiv[z].y;
}
Mnogougolnik M1(V, Massiv);
//Triangle T1;
//NRectangle R1;
 
cout << "\n\nPechataem dannie:\n\n";
cout << "Vertexes: " << V << "\n";
for(z = 0; z < V; z++)
{
    cout << "\nVertex " << z+1 << ":\n";
    cout << "x=" << M1.Vertexes[z].x << "\n";
    cout << "y=" << M1.Vertexes[z].y << "\n";
}
 
 
//===========================Treugolnik====================================
V = 3;
delete[] Massiv;
Massiv = new TPoint[V];
cout << "\nNabivaem vremennii Massiv vershinami.\n\n";
cout << "Vvedite koordinati " << V << " tochek:";
for(z = 0; z < V; z++)
{
    cout << "\nVvedite " << z+1 << " tochku mnogougolnika:\nx=";
    cin >> Massiv[z].x;
    cout << "\ny=";
    cin >> Massiv[z].y;
}
Triangle T1(Massiv);
 
cout << "\n\n=================================\n";
cout << "\n\nPechataem dannie:\n\n";
cout << "Vertexes: " << V << "\n";
for(z = 0; z < V; z++)
{
    cout << "\nVertex " << z+1 << ":\n";
    cout << "x=" << T1.Vertexes[z].x << "\n";
    cout << "y=" << T1.Vertexes[z].y << "\n";
}
 
 
 
 
//===========================Rectangle====================================
V = 2;
delete[] Massiv;
Massiv = new TPoint[V];
cout << "\nNabivaem vremennii Massiv vershinami.\n\n";
cout << "Vvedite koordinati " << V << " tochek:";
for(z = 0; z < V; z++)
{
    cout << "\nVvedite " << z+1 << " tochku mnogougolnika:\nx=";
    cin >> Massiv[z].x;
    cout << "\ny=";
    cin >> Massiv[z].y;
}
NRectangle R1(Massiv);
 
cout << "\n\n=================================\n";
cout << "\n\nPechataem dannie:\n\n";
cout << "Vertexes: " << V << "\n";
for(z = 0; z < V; z++)
{
    cout << "\nVertex " << z+1 << ":\n";
    cout << "x=" << R1.Vertexes[z].x << "\n";
    cout << "y=" << R1.Vertexes[z].y << "\n";
}
getch();
delete[] Massiv;
return 0;
}
//---------------------------------------------------------------------------

class Mnogougolnik
{
public:
int Points;  //Число точек многоугольника
TPoint *Vertexes;  //Указатель на динамический массив вершин многоугольника

/******************************************************************************
 
Создать класс «n-угольник», заданный длинами и количеством сторон. Определить
производные классы «Треугольник» и «Квадрат». Предусмотреть виртуальную функцию
для вычисления периметра фигуры, сравнить периметры треугольника и квадрата,
стороны которых введены с клавиатуры.
 
*******************************************************************************/
 
#include <iostream>
 
using namespace std;
 
class N     /// Создать класс «n-угольник»
{   
protected:          /// заданный длинами и количеством сторон
    double a;
    double b;
    double c;
    double kv;
    
public:
    N() { }
    N(double a, double b, double c, double kv)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        this->kv = kv;
    }
    
    virtual void perimetr() { }     /// Предусмотреть виртуальную функцию для вычисления периметра фигуры
    
    friend void compare();      /// сравнить периметры треугольника и квадрата
};
 
class delta: public N       ///Определить производные классы «Треугольник»
{
    double Pd;
public:
    delta(double a, double b, double c, double kv) : N(a, b, c, kv) { }
    void perimetr()
    {
        Pd = a + b + c;
        cout<<"Периметр треугольника = "<< Pd <<endl;
    }
    
    double get_Pd()
    {
        return Pd;
    }
    
 
};
 
class square: public N      /// Определить производные классы «Квадрат»
{
    double Ps;
public:
    square(double a, double b, double c, double kv) : N(a, b, c, kv) { }
    void perimetr()
    {
        Ps = kv * 4;
        cout<<"Периметр квадрата = "<< Ps <<endl;
    }
    
    double get_Ps()
    {
        return Ps;
    }
};
 
void compare(delta &ob_delta, square &ob_square)
{
    if (ob_delta.get_Pd() > ob_square.get_Ps())
    {
        cout<<"Периметр треугольника больше квадрата";
    }
    else
        cout<<"Периметр квадрата больше(или равно) треугольника";
}
 
int main()
{
    double a, b, c, kv;
    cout<<"Введите стороны треугольника: ";     /// стороны которых введены с клавиатуры.
    cin>>a>>b>>c;
    cout<<"Введите сторону квадрата: ";
    cin>>kv;
    
    N *p;
    delta ob_delta(a, b, c, kv);    /// производный конструктор передает аргументы базовому классу
    square ob_square(a, b, c, kv);
    
    p = &ob_delta;      /// вызов виртуальной функции (смотрит на передаваемые значения)
    p->perimetr();
    
    p = &ob_square;
    p->perimetr();
    
    compare(ob_delta, ob_square);   /// friend, сравнивает периметры
    
    return 0;
}