Void main ( )

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

При наследовании классов важную роль играет статус доступа компонента.

В иерархии классов (при наследовании) относительно доступности компонент принято следующее соглашение:

1) Собственные (private) методы и данные доступны только внутри класса, где они определены.

2) Защищенные (protected) компоненты доступны внутри класса, где они определены, и также доступны во все производных классах.

3) Общедоступные (public) компоненты класса – глобальны, т.е. доступны из любой точки программы.

На доступность компонент влияет также выбор ключевого слова (class, struct, union), с помощью которого объявлен класс.

Следует обратить внимание, что ни базовый, ни производный класс не могут быть объявлены с помощью union.

Классы union не могут использоваться при наследовании!

Определение производных классов:

сlass T: X, Y, Z {…};

Класс T – потомок базовых классов X, Y, Z, из которых он наследует компоненты и методы.

Наследуются методы и данные со статусом доступа public и protected!

При этом,

- еслипроизводныйкласс имеет спецификатор class, то компоненты родителя получают по умолчанию в классе потомке статус - private.

- если это struct – унаследованные компоненты имеют статус public.

class A { protected: int x;

public: float y;…};

class B: A {... }; // x, y наследуются как private

struct C: A {...}; // x, y наследуются как public

Изменить статус доступа, получаемый по умолчанию можно опять с помощью спецификаторов public, protected и private.

class D: protected A {... }; // x, y наследуются как protected

class E: public A {... }; //x наследуются как protected, а y как public

class M: private A {... }; // x, y наследуются как private

struct N:: protected A {...}; // x, y наследуются как protected

struct P: public A {... }; // x наследуются как protected, а y как public

struct N:: private A {...}; // x, y наследуются как private

Пример:

…

class A { //базовый класс

int x // закрытое данное класса А

public:

A(int xx =0) { x=xx; cout<< “ A! ”;} // конструктор класса А

int GetX () {return x;} // функция-член класса А

~A () {cout<<endl<<”DA ”; } // деструктор класса А

};

class B: public A { // производный от А класс B

int y; // закрытое данное класса B

public:

B (int yy=0) { y = yy; cout << “ B! ”; } // конструктор класса B

int GetY { return y;} // функция-член класса B

~B () { cout<< “ DB “; } // деструктор класса B

};

void main ()

{ B b (5);

cout<<endl<< “ b =” << b.GetY ();

cout<<endl<< “ a =” << b.GetX ();

}

В производный класс B включаются все данные и функции родителя А, при этом данное x -недоступно для прямого обращения из объектов класса B, но к нему можно обращаться из доступных компонентных функций класса А, которые стали полноправными членами класса B: b.GetX ();

Таким образом, через открытую функцию класса A GetX() мы получаем доступ к закрытому данному этого класса (x), а функция GetY () класса B предоставила доступ к закрытому данному (y) производного класса.

В main создается объект производного класса B, компонентному данному которого передается значение 5.

Данное класса А инициируется значением 0.

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

В нашем случае сначала вызывается конструктор A (), который по умолчанию инициирует x значением 0, а затем вызывается B(5), инициирующий y значением 5.

Деструкторы автоматически вызываются в обратном порядке в соответствии с порядком уничтожения объекта. Сначала уничтожается то, что добавилось в производном классе, а затем и базовая часть.

Результат программы:

A! B!

b= 5

a= 0

DB DA

Наличие производного класса не запрещает создавать отдельно объекты базового класса, например:

A a (7);

Дата добавления: 2015-07-15