C++. Сборник рецептов - [132]

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

#include
#include

const static int DEFAULT_BUF_SIZE = 3;
const Static int MAX_SIZE = 4096;

class Message {
public:
 Message(int bufSize = DEFAULT_BUF_SIZE) :
  bufSize_(bufSize), initBufSize_(bufSize), msgSize_(0), key_("") {
   buf_ = new char[bufSize]; // Примечание: теперь это делается в теле
                            // конструктора
 }
 ~Message() {
  delete[] buf_;
 }

 // Безопасный при исключениях конструктор копирования
 Message(const Message& orig) :
  bufSize_(orig.bufSize_), initBufSize_(orig.initBufSize_),
  msgSize_(orig.msgSize_), key_(orig.key_) {
  // Эта функция может выбросить исключение
  buf_ = new char[orig.bufSize_]; // ...здесь может произойти то же
                                  // самое
  copy(orig.buf_, orig.buf_+msgSize_, buf_); // Здесь нет
 }

 // Безопасный при исключениях оператор присваивания использующий
 // конструктор копирования
 Message& operator=(const Message& rhs) {
  Message tmp(rhs); // Копировать сообщение во временную переменную,
                    // используя конструктор копирования
  swapInternals(tmp); // Обменять значения переменных-членов и членов
                      // временного объекта
  return(*this); // После выхода переменная tmp уничтожается вместе
                 // с первоначальными данными
 }

 const char* data() {
  return(buf_);
 }

private:
 void swapInternals(Messages msg) {
  // Поскольку key_ не является встроенным типом данных, он может
  // выбрасывать исключение, поэтому сначала выполняем действия с ним
  swap(key_, msg.key_);
  // Если предыдущий оператор не выбрасывает исключение, то выполняем
  // действия со всеми переменными-членами, которые являются встроенными
  // типами
  swap(bufSize_, msg.bufSize_);
  swap(initBufSize_, msg.initBufSize_);
  swap(msgSize_, msg.msgSize_);
  swap(buf_, msg.buf_);
 }
 int bufSize_;
 int initBufSize_;
 int msgSize_;
 char* buf;
 string key_;
}

Обсуждение

Вся работа здесь делается конструктором копирования и закрытой функцией-членом swapInternals. Конструктор копирования инициализирует в списке инициализации элементарные члены и один из неэлементарных членов. Затем он распределяет память для нового буфера и копирует туда данные. Довольно просто, но почему используется такая последовательность действий? Вы могли бы возразить, что всю инициализацию можно сделать в списке инициализации, но такой подход может сопровождаться тонкими ошибками.

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

Message(const Message& orig) :
 bufSize_(orig bufSize_), initBufSize_(orig initBufSize_),
 msgSize_(orig.msgSize_), key_(orig.key_),
 buf_(new char[orig.bufSize_]) {
  copy(orig.buf_, orig.buf_+msgSize_, buf_);
}

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

int bufSize_;
int initBufSize_;
int msgSize_;
char* buf_;
string key_;

В результате buf_ будет инициализироваться перед key_. Если при инициализации key_ будет выброшено исключение, buf_ не будет уничтожен, и у вас образуется участок недоступной памяти. От этого можно защититься путем использования в конструкторе блока try/catch (см. рецепт 9.2), но проще разместить оператор инициализации buf_ в теле конструктора, что гарантирует его выполнение после операторов списка инициализации.

Выполнение функции copy не приведет к выбрасыванию исключения, так как она копирует элементарные значения. Но именно это место является тонким с точки зрения безопасности исключений: эта функция может выбросить исключение, если копируются объекты (например, если речь идет о контейнере, который параметризован типом своих элементов, T); в этом случае вам придется перехватывать исключение и освобождать связанную с ним память.

Вы можете поступить по-другому и копировать объект при помощи оператора присваивания, operator=. Поскольку этот оператор и конструктор копирования выполняют аналогичные действия (например, приравнивают члены моего класса к членам аргумента), воспользуйтесь тем, что вы уже сделали, и вы облегчите себе жизнь. Единственная особенность заключается в том, что вы можете сделать более привлекательным ваш программный код, используя закрытую функцию-член для обмена значений между данными-членами и временным объектом. Мне бы хотелось быть изобретателем этого приема, но я обязан отдать должное Гербу Саттеру (Herb Sutter) и Стефану Дьюхарсту (Stephen Dewhurst), в работе которых я впервые познакомился с этим подходом.

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