Простое наследование

Один родитель, конструкторы и операции присваивания не наследуются, деструкторы наследуются.

enum color{red, green, blue};

class monstr{

int health,ammo;

color skin;

char *name;

public:

monstr(int he=100, int am=10);

monstr(color sk);

monstr(char *nm);

monstr(monstr &M);

~monstr(){delete [] name;}

void draw( int x, int y, int scale, int position);

int get_health()

{return health;}

int get_ammo()

{return ammo;}

monstr & operator ++()

{ ++health; return *this;

}

monstr operator ++(int)

{monstr M(*this)

health++;

return M;

}

operator int()

{ return health;

}

bool operator >( monstr &M)

{ if (health > M.health)

return true;

return false;

}

const monstr& operator =(const monstr &M)

{

if (&M == this) return *this;

if (name) delete [] name;

if (M.name)

{

name = new char [strlenM.name) + 1];

strcpy(name, M.name);}

else name =0;

health = M.health;

ammo = M.ammo;

skin = M.skin;

return *this;

}

void change_health(int he)

{ health =he;

}

};

monstr::monstr(const monstr &M)

{health = M.health;

ammo = M.ammo;

skin= M.skin;

if (M.name)

{ name = new char [strlen(M.name)+1];

strcpy (name , M.name);

}

else name = 0;

}

monstr::monstr(int he, int am)

{health = he;

ammo = am;

skin = red;

name = 0;

}

monstr::monstr(color sk)

{switch (sk)

{ case red: health = 100; ammo = 10; skin = red;

name = 0; break;

case green: health = 100; ammo = 20; skin = green;

name = 0; break;

case blue: health = 100; ammo = 40; skin = blue;

name = 0; break;

}

}

monstr::monstr(char *nm)

{health = 100;

ammo = 10;

skin= red;

name = new char [strlen(nm)+1];

strcpy (name , nm);

}

void monstr::draw(int x, int y, int scale, int position)

{ cout <<x<< y<< scale<< position;}

class daemon : public monstr {

int brain;

public:

daemon (int br=100){brain = br};

daemon (color sk): monstr(sk){brain =10};

daemon (char *nm): monstr(nm){brain =10};

daemon (daemon &M) ): monstr(M){brain =10};

// -----------------

const daemon & operator =(const daemon &M)

{

if (&M == this) return *this;

brain = M.brain;

monstr:: operator = (M);

return *this;

}

//---------------------

void think();

void draw( int x, int y, int scale, int position);

};

void daemon:: think()

{…};

void daemon::draw(int x, int y, int scale, int position)

{ cout <<x<< y<< scale<< position;…}

Порядок вызова конструкторов:

1. Если в конструкторе производного класса нет явного вызова конструктора базового класса, вызывается конструктор базового класса по умолчанию.

2. Конструкторы базовых классов вызываются, начиная с верхнего уровня. Конструкторы элементов-объектов вызываются в порядке их объявления. Последним вызывается конструктор класса.

3. При нескольких базовых классов конструкторы вызываются в порядке объявления.

4. Если конструктор требует указания параметров, он должен быть явно вызван.

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

Порядок наследования деструкторов:

1. Наследуются. Если не описан, формируется по умолчанию.

2. В деструкторе производного класса не требуется явного вызова деструктора базового класса.

3. Деструкторы вызываются в порядке обратном вызову конструкторов.