Наследование. Иерархия классов.

Наследование классов может быть простым, множественным, прямым, косвенным, открытым, защищенным, закрытым и т.д. Пример простого прямого наследования:

При наследовании достигаются две основные цели.

1) Используется готовое программное обеспечение: строят иерархии классов, в которых производные классы получают элементы родительских, или базовых классов, и могут дополнять их или изменять их свойства. Классы, находящиеся ближе к началу иерархии, объединяют в себе наиболее общие черты для всех нижележащих классов. По мере продвижения вниз по иерархии классы приобретают все больше конкретных черт. Множественное наследование позволяет одному классу обладать свойствами двух и более классов.

2) Единое управление объектами всех классов иерархии. При большом количестве никак не связанных классов управление их объектами становится невозможным. Наследование позволяет решить эту задачу.

Ключи доступа

Ключи доступа регулируют возможность обращения из производных классов к элементам базовых классов.

class имя:[private|protected|public] базовый класс

{тело класса};

Пример. class A {…..};

class B {…..};

class C {…..};

class D: A, protected B, public C {…..};//по умолчанию private

Для одиночных классов, не входящих в иерархию, protected равносилен private (в теле класса). Разница между ними проявляется при наследовании.

ключ доступа	спецификатор базового класса	доступ в произ- водном классе	примечания
private	private protected public	private private private	Элементы базового класса недоступны в производном классе независимо от спецификатора базового класса
protected	private protected public	private protected protected	Элементы базового класса со спецификатором private недоступны в производном классе, со спецификаторами protected и public – доступны в производном классе функциям-элементам и друзьям. Доступ – по имени.
public	private protected public	private protected public	Элементы базового класса со спецификатором private недоступны в производном классе, со спецификатором protected – доступны в производном классе функциям-элементам и друзьям, со спецификатором public – доступны всем функциям программы. Доступ – по имени.

При закрытом наследовании доступ к элементам базового класса осуществляется только через функции-элементы базового класса. Выборочно элементы базового класса делаются доступными в производном классе следующим образом:

class B { class A: private B {

………….. ………………

public: public:

void f(); B::void f();

………….. ………………

}; };

Пример простого наследования (точка, круг)

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

#include <iostream.h>

class point {

public:

point(float=0, float=0); //конструктор с умолчанием

void setpoint(float, float);//установка координат

float getx() const {return x;} //получить координату x

float gety() const {return y;} //получить координату y

protected:

float x,y; //элементы – координаты точки

};

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

point::point(float a, float b) {setpoint(a,b);}

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

void point::setpoint(float a, float b) {x=a; y=b;}

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

class circle: public point {

public:

circle(float r=0, float x=0, float y=0);//конструктор с умолчанием

void setradius(float); //установка радиуса

float getradius(0 const; //возвращение радиуса

protected:

float radius;

};

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

//конструктор circle вызывает конструктор point с инициализаторами

//элементов-координат, затем инициализирует радиус

circle: circle(float r, float a, float b)

:point(a,b) //вызов конст-ра базового класса в списке инициализатора

{radius=r;}

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

void main()

{ point* pptr, p(3.5,5.3);

circle* cptr, c(2.7,1.2,8.9);

cout<<”p: [“<<p.getx()<<”, “<<p.gety()<<’]’<< endl // p: [3.5, 5.3]

<<”c: Центр = [“<<c.getx()<<”, “<<c.gety()<<”]; Радиус = “

<<c.getradius()<<endl; // c: Центр= [1.2, 8.9]; Радиус= 2.7

//рассмотрение объекта c как объекта p (видит только часть:

// базовый класс)

pptr=&c;

cout<<endl<<”c через pptr: [“<<pptr->getx()<<”, “<<pptr->gety()

<<’]’<<endl; // c через pptr: [1.2, 8.9]

//рассмотрение объекта c после приведения типа

cptr=(circle*)pptr; //приведение базового типа к производному

cout<<endl<<”c через cptr: Центр = [“<<cptr->getx()<<”, “

<<cptr->gety()<<”]; Радиус = “<<cptr->getradius()

<<endl; // c через cptr: Центр= [1.2, 8.9]; Радиус= 2.7

//рассмотрение объекта p как объекта c

pptr=&p;

cptr=(circle*)pptr;

cout<<endl<<”p через cptr: Центр = [“<<cptr->getx()<<”, “

<<cptr->gety()<<”]; Радиус = “<<cptr->getradius()

<<endl; // p через cptr: Центр= [3.5, 5.3]; Радиус= 4.02e-38

}

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

Примечания.

1. Производный класс circle наследует функции-элементы setpoint, getx, gety и данные-элементы x, y базового класса point.

2. В классе circle введено данное-элемент radius, определен собственный конструктор, добавлены функции-элементы setradius и getradius.

3. В базовом классе point используется protected: , чтобы данные-элементы x, y базового класса point были доступны функциям-элементам класса circle.