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

объект не остается не уничтоженным, и утечка памяти не возникает.

Поскольку оператор delete вызывает деструкторы (для типов, в которых они предусмотрены, например, таких, как vector), часто говорят, что он уничтожает (destroy) объекты, а не удаляет из памяти (deallocate).

 

 Как всегда, следует помнить, что “голый” оператор new за пределами конструктора таит в себе опасность забыть об операторе delete. Если у вас нет хорошей стратегии удаления объектов (хотя она действительно проста, см., например, класс Vector_ref из разделов 13.10 и Д.4), попробуйте включить операторы new в конструкторы, а операторы delete — в деструкторы.

Итак, все бы ничего, но как же нам получить доступ к членам вектора, используя только указатель? Обратите внимание на то, что все классы поддерживают доступ к своим членам с помощью оператора . (точка), примененного к имени объекта.

vector v(4);

int x = v.size();

double d = v.get(3);

Аналогично все классы поддерживают работу оператора –> (стрелка) для доступа к своим членам с помощью указателя на объект.

vector* p = new vector(4);

int x = p–>size();

double d = p–>get(3);

Как и операторы . (точка), оператор –> (стрелка) можно использовать для доступа к данным-членам и функциям-членам. Поскольку встроенные типы, такие как int и double, не имеют членов, то оператор –> к ним не применяется. Операторы “точка” и “стрелка” часто называют операторами доступа к членам класса (member access operators).

17.8. Путаница с типами: void* и операторы приведения типов

Используя указатели и массивы, расположенные в свободной памяти, мы вступаем в более тесный контакт с аппаратным обеспечением. По существу, наши операции с указателями (инициализация, присваивание, * и []) непосредственно отображаются в машинные инструкции. На этом уровне язык предоставляет программисту мало удобств и возможностей, предусматриваемых системой типов. Однако иногда приходится от них отказываться, даже несмотря на меньшую степень защиты от ошибок.

Естественно, мы не хотели бы совсем отказываться от защиты, представляемой системой типов, но иногда у нас нет логичной альтернативы (например, когда мы должны обеспечить работу с программой, написанной на другой языке программирования, в котором ничего не известно о системе типов языка С++). Кроме того, существует множество ситуаций, в которых необходимо использовать старые программы, разработанные без учета системы безопасности статических типов.

В таких случаях нам нужны две вещи.

• Тип указателя, ссылающегося на память без учета информации о том, какие объекты в нем размещены.

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

 

 Тип void* означает “указатель на ячейку памяти, тип которой компилятору неизвестен”. Он используется тогда, когда необходимо передать адрес из одной части программы в другую, причем каждая из них ничего не знает о типе объекта, с которым работает другая часть. Примерами являются адреса, служащие аргументами функций обратного вызова (см. раздел 16.3.1), а также распределители памяти самого нижнего уровня (такие как реализация оператора new).

Объектов типа void не существует, но, как мы видели, ключевое слово void означает “функция ничего не возвращает”.

void v;   // ошибка: объектов типа void не существует

void f(); // функция f() ничего не возвращает;

          // это не значит, что функция f() возвращает объект

          // типа void

Указателю типа void* можно присвоить указатель на любой объект. Рассмотрим пример.

void* pv1 = new int;        // OK: int* превращается в void*

void* pv2 = new double[10]; // OK: double* превращается в void*

Поскольку компилятор ничего не знает о том, на что ссылается указатель типа void*, мы должны сообщить ему об этом.

void f(void* pv)

{

  void* pv2 = pv;  // правильно (тип void* для этого

                   // и предназначен)

  double* pd = pv; // ошибка: невозможно привести тип void*

                   // к double*

  *pv = 7;    // ошибка: невозможно разыменовать void*

              // (тип объекта, на который ссылается указатель,

              // неизвестен)

  pv[2] = 9;                       // ошибка: void* нельзя индексировать

  int* pi = static_cast<int*>(pv); // OK: явное приведение

  // ...

}

 

 Оператор static_cast позволяет явно преобразовать указатели типов в родственный тип, например void* в double* (раздел A.5.7). Имя static_cast — это сознательно выбранное отвратительное имя для отвратительного (и опасного) оператора, который следует использовать только в случае крайней необходимости. Его редко можно встретить в программах (если он вообще где-то используется). Операции, такие как static_cast, называют явным преобразованием типа (explicit type conversion), или просто приведением (cast), потому что в языке C++ предусмотрены два оператора приведения типов, которые потенциально еще хуже оператора static_cast.

• Оператор reinterpret_cast может преобразовать тип в совершенно другой, никак не связанный с ним тип, например int в double*.

• Оператор const_cast позволяет отбросить квалификатор const.

Рассмотрим пример.

Register* in = reinterpret_cast<Register*>(0xff);

void f(const Buffer* p)

{

  Buffer* b = const_cast<Buffer*>(p);

  // ...

}

Первый пример — классическая ситуация, в которой необходимо применить оператор reinterpret_cast. Мы сообщаем компилятору, что определенная часть памяти (участок, начинающийся с ячейки 0xFF) рассматривается как объект класса Register (возможно, со специальной семантикой). Такой код необходим, например, при разработке драйверов устройств.

Во втором примере оператор const_cast аннулирует квалификатор const в объявлении const Buffer* указателя p. Разумеется, мы понимали, что делали.

По крайней мере, оператор static_cast не позволяет преобразовать указатели в целые числа или аннулировать квалификатор const, поэтому при необходимости привести один тип к другому следует предпочесть оператор static_cast. Если вы пришли к выводу, что вам необходимо приведение типов, подумайте еще раз: нельзя ли написать программу иначе, без приведения типов? Можно ли переписать программу так, чтобы приведение типов стало ненужным? Если вам не приходится использовать код, написанный другими людьми, или управлять аппаратным обеспечением, то, безусловно, можно и нужно обойтись без оператора static_cast. В противном случае