наследование классов

#include<iostream.h>
#include<math.h>
#include<conio.h>
#include<string.h>
 
enum shape{prizm,parallelepiped,cube,pyramid,cone,cylinder};
enum color{red,yellow,green,blue,white};
enum material{metal,wood,plastic,cardboard};
enum filter{water,milk,air,quartz_sand,vegetable_oil};
 
class Body
{
   private:
  char* name_obj;
  shape forma_obj;
  float H;
  float So;
  float Sb;
  float Sp;
  float V;
  float k;
  float P;
  float p1,p2;
  color    col_c;
  material mat_m;
  filter   fil_f;
  float thickness;
  float V1;
  float P1;
 
   public:
  float get_V()
  {
    float V=So*H*k;
    return V;
  }
 
  float get_P()
  {
    float P=p1*get_V();
    return P;
  }
 
  float get_V1()
  {
    float V1=Sp*thickness;
    return V1;
  }
 
  float get_P1()
  {
    float P1=get_P()+p2*(V-V1);
    return P1;
  }
 
 Filter(filter f,float thickness)
       {
         fil_f=f;
       }
 
 Body(char *name,color c,material m,shape forma,filter f)
      {
        name_obj=new char[strlen(name)+1];
        strcpy(name_obj,name);
        col_c=c;
        mat_m=m;
        forma_obj=forma;
        fil_f=f;
        switch(col_c)
             {
               case red:    cout<<"red ";
                            break;
               case yellow: cout<<"yellow ";
                            break;
               case green:  cout<<"green ";
                            break;
               case blue:   cout<<"blue ";
                            break;
               case white:  cout<<"white ";
                            break;
               default: cout<<"Нет такого цвета.";
                        break;
             }
        switch(mat_m)
             {
               case metal:      cout<<"metal ";
                                p1=7.874;        //плотность железа
                                break;
               case wood:       cout<<"wood ";
                                p1=0.861;       //плотность дуба
                                break;
               case plastic:    cout<<"plastic ";
                                p1=1.235;       //плотность пластика
                                break;
               case cardboard:  cout<<"cardboard ";
                                p1=0.689;       //плотность картона
                                break;
               default: cout<<"Нет такого материала.";
                        break;
             }
           if(p1!=0)
             {
               get_P();
             }
        switch(forma_obj)
              {
               case prizm:          cout<<"prizm ";
                                    k=1.0;
                                    break;
               case parallelepiped: cout<<"parallelepiped ";
                                    k=1.0;
                                    break;
               case cube:           cout<<"cube ";
                                    k=1.0;
                                    break;
               case pyramid:        cout<<"pyramid ";
                                    k=1.0/3.0;
                                    break;
               case cone:           cout<<"cone ";
                                    k=1.0/3.0;
                                    break;
               case cylinder:       cout<<"cylinder ";
                                    k=1.0;
                                    break;
               default:cout<<"Неизвестная фигура.\n";
             }
         if (k!=0)
          {
            get_V();
          }
        switch(fil_f)
               {
                 case water:         cout<<"water ";
                                     p2=1;         //плотность воды при 4С
                                     break;
                 case milk:          cout<<"milk ";
                                     p2=1.032;     //плотность молока при 20С
                                     break;
                 case air:           cout<<"air ";
                                     p2=0.001293;  //плотность воздуха при 20С
                                     break;
                 case quartz_sand:   cout<<"quartz_sand ";
                                     p2=2.65;      //плотность кварцеврго песка
                                     break;
                 case vegetable_oil: cout<<"vegetable_oil ";
                                     p2=0.87;      //плотность растительного масла
                                     break;
                 default: cout<<"Нет такого наполнителя.";
                          break;
               }
         if(p2!=0)
           {
             get_P1();
           }
        }
 
 
  void Display()
 {
   cout<<"Имя объекта - "<<name_obj<<"."<<endl;
   cout<<"Форма объекта - "<<forma_obj<<"."<<endl;
   cout<<"Площадь основания равна:          \tSo="<<So<<endl;
   cout<<"Площадь боковой поверхности равна:\tSb="<<Sb<<endl;
   cout<<"Площадь полной поверхности равна: \tSp="<<Sp<<endl;
   cout<<"Объем обекта равен:               \tV="<<get_V()<<endl;
   cout<<"Вес объекта равен:                \tP="<<get_P()<<endl;
   cout<<"Hello! I`m an object "<<name_obj<<" - "<<col_c<<' '<<mat_m<<' '<<forma_obj<<".\n";
 }
 
  ~Body()
  {  delete[]name_obj;  }
 
  void get_H(float H)
       {  this->H=H;    }
  void get_So(float So)
       {  this->So=So;  }
  void get_Sb(float Sb)
       {  this->Sb=Sb;  }
  void get_Sp(float Sp)
       {  this->Sp=Sp;  }
};
 
 class cl_prizm: public Body
{
  public:
  Filter(filter f,float thickness)
       {
         fil_f=f;
       }
 
  cl_prizm(char *name,color c,material m,shape forma,filter f,float H,float So,float Sb,float Sp):Body(name,c,m,forma,f)
 {
    get_H(H);
    get_So(So);
    get_Sb(Sb);
    get_Sp(Sp);
  }
};

Miska(double radius, double glubina)
    : Posuda(radius*radius*Pi*glubina)
{
/*Тело конструктора*/
}

//---------------------------------------------------------------------------
 
#ifndef BodyH
#define BodyH
 
#include <iostream.h>
#include <string.h>
 
enum EShape{prizm=0,parallelepiped,cube,pyramid,cone,cylinder};
enum EColor{red=0,yellow,green,blue,white};
enum EMaterial{metal=0,wood,plastic,cardboard};
enum EFilter{water=0,milk,air,quartz_sand,vegetable_oil};
 
const char* NameEShapes[cylinder+1]={"prizm", "parallelepiped", "cube", "pyramid", "cone", "cylinder"};
const char* NameEColors[white+1]={"red", "yellow", "green", "blue", "white"};
const char* NameEMaterials[cardboard+1]={"metal", "wood", "plastic", "cardboard"};
const char* NameEFilters[vegetable_oil+1]={"water", "milk", "air", "quartz_sand", "vegetable_oil"};
const float p1[cardboard+1]={7.874, 0.861, 1.235, 0.689};
const float p2[vegetable_oil+1]={1.0,1.032,0.001293,2.65,0.87};
const float k[cylinder+1]={1.0,1.0,1.0,1.0/3.0,1.0/3.0,1.0};
 
class CBody
{
    private:
          char* name;
          EShape shape;
          EColor color;
          EMaterial material;
          EFilter   filter;
          float H,So,Sb,Sp,thickness;
    public:
        CBody();
        CBody(char* name,EShape shape,EColor color, EMaterial material,
              EFilter filter, float H,float So,float Sb,float Sp,float thickness);
        ~CBody();
        float GetV1();
        float GetV2();
        float GetP1();
        float GetP2();
        const char* DisplayShape();
        const char* DisplayColor();
        const char* DisplayMaterial();
        const char* DisplayFilter();
        void Dispaly();
};
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
 
#pragma hdrstop
 
#include "Body.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
 
//---------------------------------------------------------------------------
 
CBody::CBody():name(NULL),shape(prizm),color(red),material(metal),filter(water),
               H(0.0),So(0.0),Sb(0.0),Sp(0.0),thickness(0.0)
{};
//---------------------------------------------------------------------------
 
CBody::CBody(char* name,EShape shape,EColor color, EMaterial material,
             EFilter filter, float H,float So,float Sb,float Sp,float thickness):
             name(name),shape(shape),color(color),material(material),filter(filter),
             H(H),So(So),Sb(Sb),Sp(Sp),thickness(thickness)
{}
//---------------------------------------------------------------------------
 
CBody::~CBody()
{
    if (this->name!=NULL)
        delete []this->name;
}
//---------------------------------------------------------------------------
 
float CBody::GetV1()
{return H*So*k[shape];}
//---------------------------------------------------------------------------
 
float CBody::GetV2()
{return Sp*thickness;}
//---------------------------------------------------------------------------
 
float CBody::GetP1()
{return p1[material]*GetV1();}
//---------------------------------------------------------------------------
 
float CBody::GetP2()
{return GetP1()+p2[filter]*(GetV1()-GetV2());}
//---------------------------------------------------------------------------
 
const char* CBody::DisplayShape()
{return NameEShapes[shape];}
//---------------------------------------------------------------------------
 
const char* CBody::DisplayColor()
{return NameEColors[color];}
//---------------------------------------------------------------------------
 
const char* CBody::DisplayMaterial()
{return NameEMaterials[material];}
//---------------------------------------------------------------------------
 
const char* CBody::DisplayFilter()
{return NameEFilters[filter];}
//---------------------------------------------------------------------------
 
void CBody::Dispaly()
{.
   cout<<"Имя объекта - "<<name<<"."<<endl;
   cout<<"Форма объекта - "<<shape<<"."<<endl;
   cout<<"Площадь основания равна:          \tSo="<<So<<endl;
   cout<<"Площадь боковой поверхности равна:\tSb="<<Sb<<endl;
   cout<<"Площадь полной поверхности равна: \tSp="<<Sp<<endl;
   cout<<"Объем обекта равен:               \tV="<<GetV1()<<endl;
   cout<<"Вес объекта равен:                \tP="<<GetP1()<<endl;
   cout<<"Hello! I`m an object "<<name<<" - "<<DisplayColor()<<' '<<
       DisplayMaterial()<<' '<<DisplayShape()<<".\n";
   cin.get();
}

//---------------------------------------------------------------------------
 
#pragma hdrstop
 
#include <tchar.h>
#include "body.h"
//---------------------------------------------------------------------------
 
#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
    CBody body("test",prizm,red,metal,water,1.0,1.0,1.0,1.0,1.0);
    body.Dispaly();
    return 0;
}
//---------------------------------------------------------------------------