9.2. Создание безопасного при исключениях конструктора

9.2. Создание безопасного при исключениях конструктора

Проблема

Ваш конструктор должен обеспечить базовые и строгие гарантии безопасности исключений. См. обсуждение, которое следует за определением «базовых» и «строгих» гарантий.

Решение

Используйте в конструкторе блоки try и catch, чтобы правильно завершить действия по очистке объекта, если в ходе конструирования выбрасывается исключение. В примере 9.2 приводятся простые классы Device и Broker. Broker создает два объекта Device в динамической памяти (heap), но он должен правильно очистить память от этих объектов, если при конструировании выбрасывается исключение.

Пример 9.2. Безопасный при исключениях конструктор

#include <iostream>

#include <stdexcept>

using namespace std;

class Device {

public:

 Device(int devno) {

  if (devno == 2)

   throw runtime_error("Big problem");

 }

 ~Device() {}

};

class Broker {

public:

 Broker (int devno1, int devno2) : dev1_(NULL), dev2_(NULL) {

  try {

   dev1_ = new Device(devno1); // Заключить операторы создания

   dev2_ = new Device(devno2); // объектов в динамической памяти в

                               // блок try ...

  } catch (...) {

   delete dev1_; // ...очистить память и повторно

   throw;        // выбросить исключение, если что-то не

                 // получилось.

  }

 }

 ~Broker() {

  delete dev1_;

  delete dev2_;

 }

private:

 Broker();

 Device* dev1_;

 Device* dev2_;

};

int main() {

 try {

  Broker b(1, 2);

 } catch(exception& e) {

  cerr << "Exception: " << e.what() << endl;

 }

}

Обсуждение

Сказать, что конструктор, функция-член, деструктор или что-нибудь другое «безопасно при исключениях», — значит гарантировать, что при их работе не будет утечки ресурсов и, вероятно, используемые ими объекты не будут находиться в противоречивом состоянии. В языке C++ такого рода гарантии названы базовыми и строгими.

Базовая гарантия безопасности при исключениях, которая интуитивно вполне понятна, означает, что при выбрасывании исключения текущая операция не приведет к утечке ресурсов и вовлеченный в операцию объект по-прежнему можно использовать (т.е. вы можете вызвать другие функции-члены и уничтожить объект, так как его состояние корректно). Это также означает, что программа находится в согласованном состоянии, хотя оно может быть непредсказуемым. Правила простые: если исключение выбрасывается где-нибудь в теле (например) функции-члена, созданные в динамической памяти объекты не лишаются поддержки, а вовлеченные в операцию объекты могут быть уничтожены или восстановлены в вызывающей программе. Другая гарантия, названная строгой гарантией безопасности исключений, обеспечивает неизменность состояния объекта, если операция завершается неудачно. Последнее относится к операциям, которые следуют после конструирования объекта, поскольку по определению объект, который выбрасывает исключение, всегда будет сконструирован не полностью и поэтому всегда будет иметь недостоверное состояние. Я вернусь к функциям-членам в рецепте 9.4. Теперь же давайте основное внимание уделим конструированию объектов.

В примере 9.2 определяется два класса, Device и Broker, которые делают не очень много, но с их помощью можно было бы легко представить любой сценарий работы пары устройство/брокер, когда вы имеете некоторый класс, который открывает соединение к каждому из двух устройств и управляет связью между ними. Брокер бесполезен, если доступно только одно устройство, поэтому семантика обработки транзакций при наличии брокера должна учитывать, что при выбрасывании исключения одним из двух этих устройств, когда делается попытка получения доступа к нему, должно освобождаться другое устройство. Это обеспечивает невозможность утечки памяти и других ресурсов.

Блоки try и catch сделают эту работу. В конструкторе заключите операторы по выделению динамической памяти для объекта в блок try и перехватывайте все исключения, которые выбрасываются в ходе конструирования этого объекта.

try {

 dev1_ = new Device(devno1);

 dev2_ = new Device(devno2);

} catch (...) {

 delete dev1_;

 throw;

}

Многоточие в обработчике catch означает, что любое выброшенное исключение будет перехвачено. В данном случае вам следует поступать именно так, поскольку вы лишь освобождаете память, если что-то не получилось, и затем повторно выбрасываете исключение независимо от его типа. Вам необходимо повторно выбросить исключение, чтобы клиентская программа, которая пытается инстанцировать объект Broker, могла сделать что-то полезное с исключением, например записать куда-нибудь соответствующее сообщение об ошибке.

В catch-обработчике я удаляю лишь dev1_, так как последнее выбрасывание исключения возможно только в операторе new для dev2_. Если он выбрасывает исключение, то переменной dev2_ не будет присвоено никакого значения и, следовательно, мне не нужно удалять объект dev2_. Однако, если вы что-то делаете после инициализации dev2_, вам потребуется выполнить зачистку этого объекта. Например:

try {

 dev1_ = new Device(devno1);

 dev2_ = new Device(devno2);

 foo_ = new MyClass(); // Может выбросить исключение

} catch (...) {

 delete dev1_;

 delete dev2_;

 throw;

}

В этом случае вам не следует беспокоиться об удалении указателей, которым никогда не присваивались реальные значения (если изначально вы не инициализировали их соответствующим образом), поскольку удаление указателя NULL не дает никакого эффекта. Другими словами, если присваивание значения переменной dev1_ приводит к выбрасыванию исключения, ваш catch-обработчик все же выполнит оператор delete dev2_, однако все будет нормально, если вы инициализировали его значением NULL в списке инициализации.

Как я говорил в рецепте 9.1, рассматривая основы обработки исключений, для обеспечения гибкой стратегии обработки исключений может потребоваться особая ловкость, и то же самое относится к обеспечению безопасности исключений. Подробное рассмотрение методов проектирования программного кода, безопасного при исключениях, приводится в книге «Exceptional С++», написанной Гербом Саттером (Herb Sutter) (издательство «Addison Wesley»).

Смотри также

Рецепт 9.3.