Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [50]

class StringTable {
public:
 StringTable() {}
 // Функции вставки, удаления, поиска и т.п., но нет
 // функциональности копирования/перемещения/деструкции
private:
 std::map values;
};

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

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

class StringTable {
public:
 StringTable()
 { makeLogEntry("Создание StringTable"}; }    // Добавлено
 ~StringTable()
 { mаkеLоgЕntrу("Уничтожение StringTable"); } // Добавлено
 …                                            // Прочие функции,
private:                                      // как и раньше
 std::map values;           // Как и раньше
};

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

Сюда включается и тестирование функциональности перемещения, поскольку, хотя даже этот класс и не является перемещаемым, запрос на перемещение будет компилироваться и работать. Такой запрос, как отмечалось ранее в данном разделе, приводит к выполнению копирования. Это означает, что код, “перемещающий” объекты StringTable, в действительности их копирует, т.e. копирует лежащие в их основе объекты std::map. А копирование std::map, скорее всего, окажется на порядки медленнее перемещения. Простое добавление деструктора к классу может тем самым внести значительные проблемы, связанные с производительностью! Если бы копирующие и перемещающие операции были явно определены как “= default”, такая проблема не могла бы возникнуть.

Теперь, благополучно пережив мою бесконечную болтовню о правилах, управляющих операциями копирования и перемещения в С++11, вы можете озадачиться: когда же я, наконец, обращу свое внимание на две другие специальные функции — конструктор по умолчанию и деструктор? Да прямо сейчас, в этом предложении, и только в нем, потому что для этих функций-членов почти ничего не изменилось: правила в С++11 практически те же, что и в С++98.

Резюмируем правила С++11, управляющие специальными функциями-членами.

• Конструктор по умолчанию. Правила те же, что и в С++98. Генерируется, только если класс не содержит пользовательских конструкторов.

• Деструктор. Правила по сути те же, что и в С++98; единственное отличие заключается в том, что деструктор по умолчанию является noexcept (см. раздел 3.8). Как и в С++98, деструктор является виртуальным, только если виртуальным является деструктор базового класса.

• Копирующий конструктор. То же поведение времени выполнения, что и в С++98: почленное копирующее конструирование нестатических данных-членов. Генерируется, только если класс не содержит пользовательского копирующего конструктора. Удаляется, если класс объявляет перемещающую операцию. Генерация этой функции в классе с пользовательским оператором копирующего присваивания или деструктором является устаревшей и может быть отменена в будущем.

• Оператор копирующего присваивания. То же поведение времени выполнения, что и в С++98: почленное копирующее присваивание нестатических данных-членов. Генерируется, только если класс не содержит пользовательского копирующего оператора присваивания. Удаляется, если класс объявляет перемещающую операцию. Генерация этой функции в классе с пользовательским копирующим конструктором или деструктором является устаревшей и может быть отменена в будущем.

• Перемещающий конструктор и перемещающий оператор присваивания. Каждая из этих функций выполняет почленное перемещение нестатических членов-данных. Генерируется, только если класс не содержит пользовательских копирующих операций, пользовательских перемещающих операций или пользовательский деструктор.

Обратите внимание, что в приведенных правилах ничего не говорится о том, что наличие шаблона функции-члена препятствует компиляторам генерировать специальные функции-члены. Это означает, что, если Widget имеет следующий вид:

class Widget {
 …
 template             // Создание Widget
 Widget(const T& rhs);            // из чего угодно

 template             // Присваивание Widget
 Widget& operator=(const T& rhs); // чего угодно

};

компиляторы по-прежнему будут генерировать копирующие и перемещающие операции для Widget (в предположении выполнения обычных условий, регулирующих их генерацию), несмотря на то что эти шаблоны могут инстанцироваться как копирующий конструктор и копирующий оператор присваивания (это произойдет в случае, когда T представляет собой Widget). По всей вероятности, это выглядит как крайний случай, едва стоящий ознакомления с ним, однако я упоминаю его не случайно. В разделе 5.4 вы увидите, что все это может иметь важные последствия.