Программирование. Принципы и практика использования C++ Исправленное издание - Бьёрн Страуструп

class="empty-line"/>

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

v[4]==4.4

Данный вариант класса vector чрезмерно прост, а код, использующий функции get() и set(), очень некрасив по сравнению с обычным доступом на основе квадратных скобок. Однако наша цель заключается в том, чтобы начать с небольшого и простого варианта, а затем постепенно развивать его, тестируя на каждом этапе. Эта стратегия расширения и постоянного тестирования минимизирует количество ошибок и время отладки.

17.7. Указатели на объекты класса

Понятие указателя носит универсальный характер, поэтому мы можем устанавливать его на любую ячейку памяти. Например, можем использовать указатели на объект класса vector точно так же, как и указатели на переменные типа char.

vector* f(int s)

{

  vector* p = new vector(s); // размещаем вектор в свободной

                             // памяти заполняем *p

  return p;

}

void ff()

{

  vector* q = f(4);

                  // используем *q

 delete q;        // удаляем вектор из свободной памяти

}

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

vector* p = new vector(s); // размещаем вектор в свободной памяти

delete p;                  // удаляем вектор из свободной памяти

При создании объекта класса vector в свободной памяти оператор new выполняет следующие действия:

• сначала выделяет память для объекта класса vector;

• затем вызывает конструктор класса vector, чтобы инициализировать его объект; этот конструктор выделяет память для элементов объекта класса vector и инициализирует их.

Удаляя объект класса vector, оператор delete выполняет следующие действия:

• сначала вызывает деструктор класса vector; этот деструктор, в свою очередь, вызывает деструктор элементов (если они есть), а затем освобождает память, занимаемую элементами вектора;

• затем освобождает память, занятую объектом класса vector.

Обратите внимание на то, как хорошо, что эти операторы работают рекурсивно (см. раздел. 8.5.8). Используя реальный (стандартный) класс vector, мы можем выполнить следующий код:

vector< vector<double> >* p = new vector<vector<double> > (10);

delete p;

Здесь инструкция delete p вызывает деструктор класса vector<vector<double>>, а он, в свою очередь, вызывает деструктор элементов класса vector<double>, и весь вектор аккуратно освобождается, ни один