6.6.2 Доступ к базовым классам

Подобно члену базовый класс можно описать как частный, защищенный или общий:

class X {

public:

int a;

// ...

};

class Y1 : public X { };

class Y2 : protected X { };

class Y3 : private X { };

Поскольку X - общий базовый класс для Y1, в любой функции, если есть необходимость, можно (неявно) преобразовать Y1* в X*, и притом в ней будут доступны общие члены класса X:

void f(Y1* py1, Y2* py2, Y3* py3)

{

X* px = py1; // нормально: X - общий базовый класс Y1

py1->a = 7; // нормально

px = py2; // ошибка: X - защищенный базовый класс Y2

py2->a = 7; // ошибка

px = py3; // ошибка: X - частный базовый класс Y3

py3->a = 7; // ошибка

}

Теперь пусть описаны

class Y2 : protected X { };

class Z2 : public Y2 { void f(); };

Поскольку X - защищенный базовый класс Y2, только друзья и члены Y2, а также друзья и члены любых производных от Y2 классов (в частности Z2) могут при необходимости преобразовывать (неявно) Y2* в X*. Кроме того они могут обращаться к общим и защищенным членам класса X:

void Z2::f(Y1* py1, Y2* py2, Y3* py3)

{

X* px = py1; // нормально: X - общий базовый класс Y1

py1->a = 7; // нормально

px = py2; // нормально: X - защищенный базовый класс Y2,

// а Z2 - производный класс Y2

py2->a = 7; // нормально

px = py3; // ошибка: X - частный базовый класс Y3

py3->a = 7; // ошибка

}

Наконец, рассмотрим:

class Y3 : private X { void f(); };

Поскольку X - частный базовый класс Y3, только друзья и члены Y3 могут при необходимости преобразовывать (неявно) Y3* в X*. Кроме того они могут обращаться к общим и защищенным членам класса X:

void Y3::f(Y1* py1, Y2* py2, Y3* py3)

{

X* px = py1; // нормально: X - общий базовый класс Y1

py1->a = 7; // нормально

px = py2; // ошибка: X - защищенный базовый класс Y2

py2->a = 7; // ошибка

px = py3; // нормально: X - частный базовый класс Y3,

// а Y3::f член Y3

py3->a = 7; // нормально

}

6.7 Свободная память

Если определить функции operator new() и operator delete(), управление памятью для класса можно взять в свои руки. Это также можно, (а часто и более полезно), сделать для класса, служащего базовым для многих производных классов. Допустим, нам потребовались свои функции размещения и освобождения памяти для класса employee ($$6.2.5) и всех его производных классов:

class employee {

// ...

public:

void* operator new(size_t);

void operator delete(void*, size_t);

};

void* employee::operator new(size_t s)

{

// отвести память в `s' байтов

// и возвратить указатель на нее

}

void employee::operator delete(void* p, size_t s)

{

// `p' должно указывать на память в `s' байтов,

// отведенную функцией employee::operator new();

// освободить эту память для повторного использования

}

Назначение до сей поры загадочного параметра типа size_t становится очевидным. Это - размер освобождаемого объекта. При удалении простого служащего этот параметр получает значение sizeof(employee), а при удалении управляющего - sizeof(manager). Поэтому собственные функции классы для размещения могут не хранить размер каждого размещаемого объекта. Конечно, они могут хранить эти размеры (подобно функциям размещения общего назначения) и игнорировать параметр size_t в вызове operator delete(), но тогда вряд ли они будут лучше, чем функции размещения и освобождения общего назначения.

Как транслятор определяет нужный размер, который надо передать функции operator delete()? Пока тип, указанный в operator delete(), соответствует истинному типу объекта, все просто; но рассмотрим такой пример:

class manager : public employee {

int level;

// ...

};

void f()

{

employee* p = new manager; // проблема

delete p;

}

В этом случае транслятор не сможет правильно определить размер. Как и в случае удаления массива, нужна помощь программиста. Он должен определить виртуальный деструктор в базовом классе employee:

class employee {

// ...

public:

// ...

void* operator new(size_t);

void operator delete(void*, size_t);

virtual ~employee();

};

Даже пустой деструктор решит нашу проблему:

employee::~employee() { }

Теперь освобождение памяти будет происходить в деструкторе (а в нем размер известен), а любой производный от employee класс также будет вынужден определять свой деструктор (тем самым будет установлен нужный размер), если только пользователь сам не определит его. Теперь следующий пример пройдет правильно:

void f()

{

employee* p = new manager; // теперь без проблем

delete p;

}

Размещение происходит с помощью (созданного транслятором) вызова

employee::operator new(sizeof(manager))

а освобождение с помощью вызова

employee::operator delete(p,sizeof(manager))

Иными словами, если нужно иметь корректные функции размещения и освобождения для производных классов, надо либо определить виртуальный деструктор в базовом классе, либо не использовать в функции освобождения параметр size_t. Конечно, можно было при проектировании языка предусмотреть средства, освобождающие пользователя от этой проблемы. Но тогда пользователь "освободился" бы и от определенных преимуществ более оптимальной, хотя и менее надежной системы.

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

class X {

// ...

public:

// ...

virtual void f(); // в X есть виртуальная функция, поэтому

// определяем виртуальный деструктор

virtual ~X();

};