Программирование. Принципы и практика использования C++ Исправленное издание, стр. 229

Shape* fct()

{

Text tt(Point(200,200),"Annemarie");

// ...

Shape* p = new Text(Point(100,100),"Nicholas");

return p;

}

void f()

{

Shape* q = fct();

// ...

delete q;

}

Этот код выглядит логичным — и он действительно логичен. Все работает, но посмотрите, как именно работает, ведь этот код является примером элегантного, важного и простого метода. При выходе из функции

fct()

объект

tt

класса

Text

(см. раздел 3.11), существующий в ней, уничтожается вполне корректно. Класс

Text

имеет член типа

string

, у которого обязательно нужно вызвать деструктор, — класс

string

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

vector

. Для объекта

tt

это просто; компилятор вызывает сгенерированный деструктор класса

Text

, как описано в разделе 17.5.1. А что можно сказать об объекте класса

Text

возвращаемом функцией

fct()

? Вызывающая функция

f()

понятия не имеет о том, что указатель

q

ссылается на объект класса

Text

; ей известно лишь, что он ссылается на объект класса

Shape

. Как же инструкция

delete q

сможет вызвать деструктор класса

Text

В разделе 14.2.1 мы вскользь упомянули о том, что класс

Shape

имеет деструктор. Фактически в классе

Shape

есть виртуальный деструктор. В этом все дело. Когда мы выполняем инструкцию

delete q

, оператор

delete

анализирует тип указателя

q

, чтобы увидеть, нужно ли вызывать деструктор, и при необходимости он его вызывает. Итак, инструкция

delete q

вызывает деструктор

~Shape()

класса

Shape

. Однако деструктор

~Shape()

является виртуальным, поэтому с помощью механизма вызова виртуальной функции (см. раздел 17.3.1) он вызывает деструктор класса, производного от класса

Shape

, в данном случае деструктор

~Text()

. Если бы деструктор

Shape::~Shape()

не был виртуальным, то деструктор

Text::~Text()

не был бы вызван и член класса

Text

, имеющий тип

string

, не был бы правильно уничтожен.

Запомните правило: если класс содержит виртуальную функцию, в нем должен быть виртуальный деструктор. Причины заключаются в следующем.

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

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

new

3. Если объект производного класса размещается в памяти с помощью оператора

new

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

Обратите внимание на то, что деструкторы вызываются неявно или косвенно с помощью оператора

delete

. Они никогда не вызываются непосредственно. Это позволяет избежать довольно трудоемкой работы.

ПОПРОБУЙТЕ

Напишите небольшую программу, используя базовые классы и члены, в которых определены конструкторы и деструкторы, выводящие информацию о том, что они были вызваны. Затем создайте несколько объектов и посмотрите, как вызываются конструкторы и деструкторы.

17.6. Доступ к элементам

Для того чтобы нам было удобно работать с классом

vector

, нужно читать и записывать элементы. Для начала рассмотрим простые функции-члены

get()

set()

// очень упрощенный вектор чисел типа double

class vector {

int sz; // размер

double* elem; // указатель на элементы

public:

vector(int s):

sz(s), elem(new double[s]) { /* */} // конструктор

~vector() { delete[] elem; } // деструктор

int size() const { return sz; } // текущий

// размер

double get(int n) const { return elem[n]; } // доступ: чтение

void set(int n, double v) { elem[n]=v; } // доступ: запись

};

Функции

get()

set()

обеспечивают доступ к элементам, применяя оператор

[]

к указателю

elem

Теперь мы можем создать вектор, состоящий из чисел типа

double

, и использовать его.

vector v(5);

for (int i=0; i<v.size(); ++i) {

v.set(i,1.1*i);

cout << "v[" << i << "]==" << v.get(i) << '\n';

}

Результаты выглядят так:

v[0]==0

v[1]==1.1

v[2]==2.2

v[3]==3.3