• 47. Определяйте и инициализируйте переменные-члены в одном порядке
  • 48. В конструкторах предпочитайте инициализацию присваиванию
  • 49. Избегайте вызовов виртуальных функций в конструкторах и деструкторах
  • 50. Делайте деструкторы базовых классов открытыми и виртуальными либо защищенными и невиртуальными
  • 51. Деструкторы, функции освобождения ресурсов и обмена не ошибаются
  • 52. Копируйте и ликвидируйте согласованно
  • 53. Явно разрешайте или запрещайте копирование
  • 54. Избегайте срезки. Подумайте об использовании в базовом классе клонирования вместо копирования
  • 55. Предпочитайте канонический вид присваивания
  • 56. Обеспечьте бессбойную функцию обмена
  • Конструкторы, деструкторы и копирование

    Если стандарт привел вас к обрыву, это еще не значит, что вы должны прыгнуть с него.

    (— Норман Даймонд (Norman Diamond))

    О Большой Четверке специальных функций было сказано достаточно, чтобы вы не удивлялись тому, что им посвящен отдельный раздел. Здесь собраны знания и практика, связанные с конструкторами по умолчанию, копирующими конструкторами, копирующим присваиванием и деструкторами.

    Одна из причин, по которым при работе с этими функциями следует быть особенно внимательными, заключается в том, что если вы дадите компилятору хотя бы полшанса — он тут же напишет эти функции за вас. Еще одна причина состоит в том, что С++ по умолчанию рассматривает классы как типы-значения, но далеко не все типы именно таковы (см. рекомендацию 32). Надо отчетливо понимать, когда следует писать (или запрещать) эти специальные функции явно, и следовать правилам и рекомендациям из этого раздела — это поможет вам в написании корректного, расширяемого и безопасного кода.

    В этом разделе мы считаем наиболее значимой рекомендацию 51 — "Деструкторы, функции освобождения ресурсов и обмена не ошибаются".

    47. Определяйте и инициализируйте переменные-члены в одном порядке

    Резюме

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

    Обсуждение

    Рассмотрим следующий код:

    class Employee {

     string email_, firstName_, lastName_;

    public:

     Employee( const char* firstName, const char* lastName ) :

      firstName_(firstName), lastName_(lastName),

      email_(firstName_+"."+lastName_+"@acme.com") {}

    };

    Этот код содержит ошибку, столь же неприятную, сколь и трудно обнаруживаемую. Поскольку член

    email_
    объявлен в определении класса до
    first_
    и
    last_
    , он будет инициализирован первым и будет пытаться использовать еще не инициализированные поля. Более того, если определение конструктора находится в отдельном файле, то выявить такое удаленное влияние порядка объявления переменных-членов класса на корректность конструктора окажется еще труднее.

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

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

    Многие компиляторы (но не все) выдают предупреждение при нарушении этого правила.

    Ссылки

    [Cline99] §22.03-1] • [Dewhurst03] §52-53 • [Koenig97] §4 • [Lakos96] §10.3.5 • [Meyers97] §13 • [Murray93] §2.1.3 • [Sutter00] §47

    48. В конструкторах предпочитайте инициализацию присваиванию

    Резюме

    В конструкторах использование инициализации вместо присваивания для установки значений переменных-членов предохраняет от ненужной работы времени выполнения при том же объеме вводимого исходного текста.

    Обсуждение

    Конструкторы генерируют скрытый код инициализации. Рассмотрим следующий код:

    class A {

     string s1_, s2_;

    public:

     A() { s1_ = "Hello, "; s2_ = "world"; }

    };

    В действительности сгенерированный код конструктора выглядит так, как если бы вы написали:

    А() : s1_(), s2_() { s1_ = "Hello, "; s2_ = "world"; }

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

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

    А() : s1_("Hello, "), s2_("world ") { }

    Эта методика не является преждевременной оптимизацией; это — избежание преждевременной пессимизации (см. рекомендацию 9).

    Исключения

    Всегда выполняйте захват неуправляемого ресурса (например, выделение памяти оператором

    new
    , результат которого не передается немедленно конструктору интеллектуального указателя) в теле конструктора, а не в списке инициализации (см. [Sutter02]). Конечно, лучше всего вообще не использовать таких небезопасных и не имеющих владельца ресурсов (см. рекомендацию 13).

    Ссылки

    [Dewhurst03] §51, §59 • [Keffer95] pp.13-14 • [Meyers97] §12 • [Murray93] §2.1.31 • [Sutter00] §8, §47 • [Sutter02] §18

    49. Избегайте вызовов виртуальных функций в конструкторах и деструкторах

    Резюме

    Внутри конструкторов и деструкторов виртуальные функции теряют виртуальность. Хуже того — все прямые или косвенные вызовы нереализованных чисто виртуальных функций из конструктора или деструктора приводят к неопределенному поведению. Если ваш дизайн требует виртуальной передачи в производный класс из конструктора или деструктора базового класса, следует воспользоваться иной методикой, например, постконструкторами.

    Обсуждение

    В C++ полный объект конструируется по одному базовому классу за раз.

    Пусть у нас есть базовый класс

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

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

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

    • Перекладывание ответственности. Можно просто документировать необходимость вызова в пользовательском коде постконструктора после создания объекта.

    • Отложенная постинициализация. Можно выполнять постинициализацию при первом вызове функции-члена, для чего использовать в базовом классе флаг типа

    bool
    , который показывает, был уже вызван постконструктор или нет.

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

    • Использование функции-фабрики. Таким способом вы можете легко обеспечить принудительный вызов функции-постконструктора (см. примеры к данной рекомендации).

    Ни одна из методик постконструирования не является идеальной. Наихудшее, что можно сделать, — это потребовать, чтобы пользователь класса вручную вызывал постконструктор. Однако даже наилучшие способы решения данной задачи требуют отличного от обычного синтаксиса конструирования объекта (что легко проверяется в процессе компиляции) и/или сотрудничества с авторами производных классов (что невозможно проверить в процессе компиляции).

    Примеры

    Пример. Использование функции-фабрики для принудительного вызова постконструктора. Рассмотрим следующий код:

    class B {                      // Корень иерархии

    protected:

     В() {/*...*/ }

     virtual void PostInitialize() // Вызывается сразу

      {/*...*/}                    // после конструирования


    publiс:

     template<class T>

     static shared_ptr<T> Create() // Интерфейс для

     {                             // создания объектов

      shared_ptr<T> p(new T);

      p->PostInitialize();

      return p;

     }

    };


    class D : public B { /* ... */ }; // Некоторый производный

                                      // класс


    shared_ptr<D> p = D::Create<D>(); // Создание объекта D

    Этот не вполне надежный дизайн основан на ряде компромиссов.

    • Производные классы, такие как

    D
    , не должны иметь открытых конструкторов. В противном случае пользователи
    D
    смогут создавать объекты
    D
    , для которых не будет вызываться функция
    PostInitialize
    .

    • Создание объекта использует оператор

    new
    , который, однако, может быть перекрыт классом
    В
    (см. рекомендации 45 и 46).

    • Класс

    D
    обязательно должен определить конструктор с теми же параметрами, что и у конструктора класса
    B
    . Смягчить проблему может наличие нескольких перегрузок функции
    Create
    ; эти перегрузки могут даже быть шаблонами.

    • Если перечисленные требования удовлетворены, данный дизайн гарантирует, что функция

    PostInitialize
    будет вызвана для любого полностью сконструированного объекта класса, производного от
    B
    . Функция
    PostInitialize
    не обязательно должна быть виртуальной; однако она может свободно вызывать виртуальные функции.

    Ссылки

    [Alexandrescu01] §3 • [Boost] • [Dewhurst03] §75 • [Meyers97] §46 • [Stroustrup00] §15.4.3 • [Taligent94]

    50. Делайте деструкторы базовых классов открытыми и виртуальными либо защищенными и невиртуальными

    Резюме

    Удалять или не удалять — вот в чем вопрос! Если следует обеспечить возможность удаления посредством указателя на базовый класс, то деструктор базового класса должен быть открытым и виртуальным. В противном случае он должен быть защищенным и невиртуальным.

    Обсуждение

    Это простое правило иллюстрирует достаточно тонкий вопрос и отражает современное использование наследования и принципов объектно-ориентированного проектирования.

    Для данного базового класса

    Base
    вызывающий код может пытаться удалять производные от него объекты посредством указателей на
    Base
    . Если деструктор
    Base
    открытый и невиртуальный (свойства по умолчанию), он может быть случайно вызван для указателя, который в действительности указывает на производный объект, и в этом случае мы получим неопределенное поведение. Такое состояние дел привело к тому, что в старых стандартах кодирования требовалось делать деструкторы всех без исключения базовых классов виртуальными. Однако это уже перебор (даже если это и оправдано в общем случае); вместо этого следует использовать правило, согласно которому деструктор базового класса должен быть виртуальным тогда и только тогда, когда он открытый.

    Написание базового класса представляет собой определение абстракции (см. рекомендации с 35 по 37). Вспомним, что для каждой функции-члена, участвующей в абстракции, вы должны решить:

    • должна ли она вести себя виртуально или нет;

    • должна ли она быть открыто доступна всему вызывающему коду посредством указателя на

    Base
    или она должна представлять собой скрытую внутреннюю деталь реализации.

    Как описано в рекомендации 39, для обычных функций-членов следует сделать выбор между возможностью их вызова посредством указателя Base* невиртуально (но, возможно, с виртуальным поведением, если эти функции вызывают виртуальные функции, как, например, в шаблонах проектирования NVI или Template Method), виртуально либо невозможностью такого вызова вообще. Шаблон проектирования NVI представляет собой методику, которая позволяет обойтись без открытых виртуальных функций.

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

    Base*
    или невозможности вызова вообще; выбор невиртуального вызова в данном случае неприменим. Следовательно, деструктор базового класса виртуален, если он может быть вызван (т.е. открыт), и невиртуален в противном случае.

    Заметим, что шаблон проектирования NVI не может быть применен к деструктору, поскольку конструкторы и деструкторы не могут осуществлять глубокие виртуальные вызовы (см. рекомендации 39 и 55).

    Вывод: всегда явно пишите деструктор базового класса, поскольку неявно сгенерированный деструктор является открытым и невиртуальным.

    Примеры

    Клиентский код должен либо быть способен полиморфно удалять объекты посредством указателя на базовый класс, либо не должен этого делать. Каждый выбор определяет свой дизайн.

    • Пример 1. Базовые классы с полиморфным удалением. Если должно быть разрешено полиморфное удаление, то деструктор должен быть открытым (в противном случае вызывающий код не сможет к нему обратиться) и должен быть виртуальным (в противном случае его вызов приведет к неопределенному поведению).

    • Пример 2. Базовые классы без полиморфного удаления. Если полиморфное удаление не должно быть разрешено, деструктор должен не быть открытым (чтобы вызывающий код не мог к нему обратиться) и не должен быть виртуальным (потому что виртуальность ему не нужна).

    Классы стратегий часто используются в качестве базовых для удобства, а не для обеспечения полиморфного поведения. Их деструкторы рекомендуется делать защищенными и невиртуальными.

    Исключения

    Некоторые компонентные архитектуры (например, COM или CORBA) не используют стандартный механизм удаления и применяют для этого различные собственные протоколы освобождения объектов. Следуйте шаблонам и идиомам этих архитектур и соответствующим образом адаптируйте данную рекомендацию.

    Рассмотрим также еще один редкий случай.

    • В одновременно является как базовым классом, так и конкретным классом, для которого могут создаваться объекты (так что деструктор этого класса должен быть открытым, чтобы было можно создавать и уничтожать объекты данного типа).

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

    Тогда несмотря на то, что деструктор оказывается открытым, имеется огромный соблазн не делать его виртуальным, поскольку такая первая виртуальная функция может привести к излишним расходам времени выполнения из-за добавления функциональности, которая нам совсем не нужна.

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

    std::unary_function
    .

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

    unary_function
    представляет собой набор определений
    typedef
    , который не предназначен для создания объектов данного типа. В действительности бессмысленно давать ему открытый деструктор; лучше было бы последовать совету данной рекомендации и сделать его деструктор защищенным и невиртуальным.

    Ссылки

    [Cargill92] pp. 77-79, 207 • [Cline99] §21.06, 21.12-13 • [Henricson97] pp. 110-114 • [Koenig97] Chapters 4,11 • [Meyers97] §14 • [Stroustrup00] §12.4.2 • [Sutter02] §27 • [Sutter04] § 18

    51. Деструкторы, функции освобождения ресурсов и обмена не ошибаются

    Резюме

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

    Обсуждение

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

    Рассмотрим следующие советы и требования, найденные в Стандарте С++.

    Если деструктор, вызванный в процессе свертки стека, выходит с исключением, вызывается функция

    terminate
    (15.5.1). Поэтому деструкторы должны в общем случае перехватывать исключения и не позволять им распространиться за пределы деструктора.

    ( [C++03] §15.2(3))

    В стандартной библиотеке C++ не определен ни один деструктор [включая деструкторы любого типа, используемого для инстанцирования шаблона стандартной библиотеки], генерирующий исключение.

    (— [C++03] §17.4.4.8(3))

    Деструкторы являются специальными функциями, и компилятор автоматически вызывает их в различных контекстах. Если вы пишете класс — назовем его, к примеру,

    Nefarious
    [2] — деструктор которого может давать сбой (обычно посредством генерации исключения; см. рекомендацию 72), то вы столкнетесь с такими последствиями.

    • Объекты

    Nefarious
    трудно безопасно использовать в обычных функциях. Вы не можете надежно инстанцировать автоматические объекты
    Nefarious
    в области видимости, если возможен выход из этой области видимости посредством исключения. Если это произойдет, деструктор
    Nefarious
    (вызываемый автоматически) может попытаться сгенерировать исключение, которое приведет к неожиданному завершению всей программы посредством вызова Терминатора —
    std::terminate
    (см. также рекомендацию 75).

    • Трудно безопасно использовать классы с членами или базовыми классами

    Nefarious
    . Плохое поведение класса Nefarious распространяется на все классы, для которых он является базовым или у которых имеются члены этого типа.

    • Вы не можете надежно создавать глобальные либо статические объекты

    Nefarious
    . Исключение, которое может быть сгенерировано их деструкторами, невозможно перехватить.

    • Вы не можете надежно создавать массивы объектов

    Nefarious
    . Коротко говоря, массивы при наличии деструкторов, которые могут генерировать исключения, обладают неопределенным поведением, поскольку в этой ситуации просто невозможно придумать способ разумного отката. (Подумайте сами: какой именно код должен сгенерировать компилятор для создания массива из десяти объектов
    Nefarious
    , если у четвертого объекта в конструкторе происходит генерация исключения, а при откате, когда вызываются деструкторы уже сконструированных объектов, один или несколько деструкторов генерируют исключения? Удовлетворительного ответа в этой ситуации просто нет.)

    • Вы не можете использовать объекты

    Nefarious
    в стандартных контейнерах. Объекты
    Nefarious
    нельзя хранить в стандартных контейнерах или использовать их с какими-то другими частями стандартной библиотеки. Стандартная библиотека запрещает использование деструкторов, которые могут генерировать исключения.

    Функции освобождения ресурсов, включая специальным образом перегруженные операторы

    operator delete
    и
    operator delete[]
    , попадают в ту же категорию, поскольку в общем случае они также используются в процессе "зачистки", в частности, в процессе обработки исключений.

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

    operator=
    для некоторого типа
    T
    , который основан на выполнении копирующего конструктора, за которым следует вызов функции обмена, не генерирующей исключений:

    T& T::operator=(const T& other) {

     T temp(other);

     Swap(temp);

    }

    (см. также рекомендацию 56)

    К счастью, область видимости сбоя при освобождении ресурса имеет определенно меньший размер. Если для сообщения об ошибке используются исключения, убедитесь, что рассматриваемые функции обрабатывают все возможные исключения и прочие ошибки, которые могут возникнуть при работе функций. (В случае исключений просто оберните все, что делает ваш деструктор, в блок

    try/catch(...)
    .) Это чрезвычайно важно, поскольку деструктор может быть вызван в кризисной ситуации, такой как сбой при выделении системного ресурса (например, памяти, файлов, блокировок, портов, окон или других системных объектов).

    При использовании в качестве механизма обработки ошибок исключений следует документировать такое поведение, объявляя такие функции с закомментированной пустой спецификацией исключений

    /* throw() */
    (см. рекомендацию 75).

    Ссылки

    [C++03] §15.2(3), §17.4.4.8(3) • [Meyers96] §11 • [Stroustrup00] §14.4.7, §E.2-4 • [Sutter00] §8, §16 • [Sutter02] §18-19

    52. Копируйте и ликвидируйте согласованно

    Резюме

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

    Обсуждение

    Если вам требуется определить одну из трех перечисленный функций, это означает, что вам требуется нечто большее, чем поведение этой функции по умолчанию, а все эти функции асимметрично взаимосвязаны.

    • Если вы пишете или запрещаете копирующий конструктор или оператор копирующего присваивания, то, вероятно, вы должны сделать то же самое и для другой функции из этой пары. Если одна функция выполняет некоторую "специальную" работу, вероятно, другая должна делать что-то аналогичное, так как эти две функции должны иметь одинаковое действие (см. рекомендацию 53, которая поясняет этот пункт).

    • Если вы явно пишете копирующие функции, вероятно, вам надо явно написать и деструктор. Если "специальная" работа в копирующем конструкторе заключается в выделении или дублировании некоторого ресурса (например, памяти, файла, сокета), то вы должны освободить этот ресурс в деструкторе.

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

    Во многих случаях хранение корректно инкапсулированного ресурса с использованием идиомы RAII позволяет полностью избежать самостоятельной разработки указанных операций (см. рекомендацию 13).

    Предпочитайте специальные члены, сгенерированные компилятором. Только они могут рассматриваться как "тривиальные", и как минимум один крупный производитель STL использует оптимизацию для классов с тривиальными специальными функциями. Похоже, вскоре это станет распространенным явлением.

    Исключения

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

    В редких случаях классы, имеющие члены странных типов (например, ссылки,

    std::auto_ptr
    ), являются исключениями, поскольку они имеют необычную семантику копирования. В классе, хранящем ссылку или
    auto_ptr
    , вам, вероятно, потребуется написать копирующий конструктор и оператор присваивания, но деструктор по умолчанию будет работать корректно. (Заметим, что использование члена, являющегося ссылкой или
    auto_ptr
    , почти всегда ошибочно).

    Ссылки

    [Cline99] §30.01-14 • [Koenig97] §4 • [Stroustrup00] §5.5, §10.4 • [SuttHysl04b]

    53. Явно разрешайте или запрещайте копирование

    Резюме

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

    Обсуждение

    Распространенной ошибкой (и не только среди новичков) является игнорирование семантики копирования и присваивания при определении класса. Это характерно для маленьких вспомогательных классов, таких как предназначенные для поддержки идиомы RAII (см. рекомендацию 13).

    Убедитесь, что ваш класс предоставляет осмысленное копирование (или не предоставляет его вовсе). Вот возможные варианты.

    • Явное запрещение обеих функций. Если копирование для вашего типа лишено смысла, запретите как копирующее конструирование, так и копирующее присваивание, объявив их как закрытые нереализованные функции:

    class T { // ...

    private:                 // Делаем T некопируемым

     T(const T&);            // Функция не реализована

     T& operator=(const T&); // Функция не реализована

    };

    • Явное написание обеих функций. Если для объектов

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

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

    Заметим, что запрещение копирования и копирующего присваивания означает, что вы не можете поместить объекты

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

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

    Ссылки

    [Dewhurst03] §88 • [Meyers97] §11 • [Stroustrup00] §11.2.2

    54. Избегайте срезки. Подумайте об использовании в базовом классе клонирования вместо копирования

    Резюме

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

    Clone
    , если пользователям вашего класса необходимо получать полиморфные (полные, глубокие) копии.

    Обсуждение

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

    class B { /* ... */ };


    class D : public B { /* ... */ };


    // Оп! Получение объекта по значению

    void Transmogrify(B obj);


    void Transubstantiate(B& obj) { // Все нормально -

                                    // передача по ссылке

     Transmogrify(obj);             // Плохо! Срезка объекта!

     // ...

    }


    D d;

    Transubstantiate(d);

    Программист намерен работать с объектами

    В
    и производных классов полиморфно. Однако, по ошибке (или усталости — к тому же и кофе закончился…) программист или просто забыл написать
    &
    в сигнатуре
    Transmogrify
    , или собирался создать копию, но сделал это неверно. Код компилируется без ошибок, но когда функция
    Transmogrify
    вызывается с передачей ей объекта
    D
    , он мутирует в объект B. Это связано с тем, что передача по значению приводит к вызову
    B::В(const B&)
    , т.е. копирующего конструктора
    В
    , параметр которого
    const B&
    представляет собой автоматически преобразованную ссылку на
    d
    . Что приводит к полной потере динамического, полиморфного поведения, из-за которого в первую очередь и используется наследование.

    Если, как автор класса

    В
    , вы хотите разрешить срезку, но не хотите, чтобы она могла происходить по ошибке, для такого случая существует один вариант действий, о котором мы упомянем для полноты изложения, но не рекомендуем использовать его в коде, к которому предъявляется требование переносимости: вы можете объявить копирующий конструктор
    В
    как
    explicit
    . Это может помочь избежать неявной срезки, но кроме этого запрещает все передачи параметров данного типа по значению (что может оказаться вполне приемлемым для базовых классов, объекты которых все равно не должны создаваться; см. рекомендацию 35).

    // Объявляем копирующий конструктор как explicit (у данного

    // решения имеется побочное действие, так что требуется

    // улучшение этого метода)

    class B { // ...

    public:

     explicit B(const B& rhs);

    };


    class D : public B { /* ... */ };

    Вызывающий код все равно в состоянии выполнить срезку, если это необходимо, но должен делать это явно:

    void Transmogrify(B obj); // Теперь эта функция вообще не

                              // может быть вызвана (!)


    void Transmogrify2(const B& obj) // Идиома для намерения в

    {                                // любом случае получить

     В b( obj );                     // параметр obj по значению

     // ...                          // (с возможной срезкой)

    }


    B b;              // Базовые классы не должны быть конкретными

    D d;              // (см. рекомендацию 35), но допустим это

    Transmogrify(b);  // Должна быть ошибка (см. примечание)

    Transmogrify(d);  // Должна быть ошибка (см. примечание)

    Transmogrify2(d); // Все в порядке

    Примечание: на момент написания данной рекомендации некоторые компиляторы ошибочно допускали один или оба приведенных вызова функции

    Transmogrify
    . Эта идиома вполне стандартна, но (пока что) не полностью переносима.

    Имеется лучший способ предупреждения срезки, с более высокой степенью переносимости. Пусть, например, функция наподобие

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

    // добавление функции Clone (уже лучше, но все еще требуется

    // усовершенствование)

    class B { // ...

    public:

     virtual B* Clone() const = 0;

    protected:

     B(const B&);

    };


    class D : public B { // ...

    public:

     virtual D* Clone() const { return new D(*this); }

    protected:

     D( const D& rhs ): B(rhs) {/*...*/ }

    };

    Теперь попытка срезки будет (переносимо) генерировать ошибку времени компиляции, а объявление функции

    Clone
    как чисто виртуальной заставляет непосредственный производный класс перекрыть ее. К сожалению, с данным решением все еще связаны две проблемы, которые компилятор не в состоянии обнаружить: в классе, производном от производного, функция
    Clone
    может оказаться неперекрытой, а перекрытие
    Clone
    может реализовать ее некорректно, так что копия будет не того же типа, что и оригинал. Функция
    Clone
    должна следовать шаблону проектирования Nonvirtual Interface (NVI; см. рекомендацию 39), который разделяет открытую и виртуальную природы
    Clone
    и позволяет вам использовать ряд важных проверок:

    class В { // ...

    publiс:

     B* Clone() const { // Невиртуальная функция

      B* р = DoClone();

      assert(typeid(*p) == typeid(*this) &&

       "DoClone incorrectly overridden");

      return p; // проверка типа, возвращаемого DoClone

     }

    protected:

     B(const B&);

    private:

     virtual B* DoClone() const = 0;

    };

    Функция

    Clone
    теперь является невиртуальным интерфейсом, используемым вызывающим кодом. Производные классы должны перекрыть функцию
    DoClone
    . Дополнительная проверка обнаружит все копии, которые имеют тип, отличный от оригинала, тем самым оповещая, что в некотором производном классе не перекрыта функция
    DoClone
    ; в конце концов, задача
    assert
    состоит именно в обнаружении и сообщении о таких программных ошибках (см. рекомендации 68 и 70).

    Исключения

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

    Ссылки

    [Dewhurst03] §30, §76, §94 • [Meyers96] §13 • [Meyers97] §22 • [Stroustrup94] §11.4.4 • [Stroustrup00] §12.2.3

    55. Предпочитайте канонический вид присваивания

    Резюме

    При реализации оператора

    operator=
    предпочитайте использовать канонический вид — невиртуальный с определенной сигнатурой.

    Обсуждение

    Предпочтительно объявлять копирующее присваивание для типа

    T
    с одной из следующих сигнатур (см. [Stroustrup00] и [Alexandrescu03a]):

    T& operator=(const T&); // классический вид

    T& operator=(T);        // потенциально оптимизированный

                            // вид (см. рекомендацию 27)

    Второй вариант имеет смысл использовать, если вам в любом случае требуется копия аргумента в теле вашего оператора, как, например, при использовании идиомы, основанной на использовании функции обмена (см. рекомендацию 56).

    Избегайте делать любой оператор присваивания виртуальным (см. [Meyers96] §33 и [Sutter04] §19). Если вы полагаете, что вам требуется виртуальное поведение присваивания, обратитесь сначала к указанной литературе. Если и после этого вы стоите на своем, то лучше использовать виртуальную именованную функцию, а не оператор (например,

    virtual void Assign(const T&);
    ).

    He возвращайте

    const T&
    . Хотя этот тип возвращаемого значения имеет то преимущество, что защищает от странных присваиваний наподобие
    (a=b)=c
    , главным его недостатком является то, что вы не сможете поместить объекты типа
    T
    в контейнеры стандартной библиотеки; эти контейнеры требуют, чтобы оператор присваивания возвращал тип
    T&
    .

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

    Убедитесь, что ваш оператор присваивания безопасен в смысле присваивания самому себе. Избегайте написания оператора копирующего присваивания, который для корректной работы полагается на проверку присваивания самому себе; зачастую это говорит о недостаточной безопасности в смысле исключений. Если вы пишете копирующее присваивание с использованием идиомы обмена (см. рекомендацию 56), то вы автоматически обеспечиваете как строгую безопасность в смысле исключений, так и безопасность в смысле присваивания самому себе. Если присваивание самому себе часто встречается в программе из-за использования ссылочных синонимов или по каким-то иным причинам, проверка присваивания самому себе может использоваться в качестве средства оптимизации во избежание лишней работы.

    Явно вызывайте все операторы присваивания базовых классов и всех данных-членов ([Meyers97] §16); обратите внимание, что идиома обмена автоматически заботится обо всех этих вещах. Возвращайте из оператора присваивания значение

    *this
    ([Meyers97] §15).

    Ссылки

    [Alexandrescu03a] • [Cargill92] pp. 41-42, 95 • [Cline99] §24.01-12 • [Koenig97] §4 • [Meyers96] §33 • [Meyers97] §17 • [Murray93] §2.2.1 • [Stroustrup00] §10.4.4.1, §10.4.6.3 • [Sutter00] §13, §38, §41 • [Sutter04] §19

    56. Обеспечьте бессбойную функцию обмена

    Резюме

    Обычно имеет смысл предоставить для класса функцию

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

    Обсуждение

    Обычно функция

    swap
    выглядит примерно следующим образом (здесь
    U
    — некоторый пользовательский тип):

    class T { // ...

    public:

     void swap(T& rhs) {

      member1_.swap(rhs.member1_);

      std::swap(member2_, rhs.member2_);

     }

    private:

     U member1_;

     int member2_;

    };

    Для примитивных типов и стандартных контейнеров можно использовать

    std::swap
    . Другие классы могут реализовывать обмен в виде функций-членов с различными именами.

    Рассмотрим использование

    swap
    для реализации копирующего присваивания посредством копирующего конструктора. Приведенная далее реализация оператора operator= обеспечивает строгую гарантию (см. рекомендацию 71), хотя и ценой создания дополнительного объекта, что может оказаться неприемлемым, если имеется более эффективный способ выполнения безопасного присваивания объектов типа T:

    T& T::operator=(const T& other) { // Вариант 1 (традиционный)

     T temp(other);

     swap(temp);

     return *this;

    }


    T& T::operator=(T temp) { // Вариант 2 (см. рекомендацию 27)

     swap(temp);              // Обратите внимание на передачу

     return *this;            // temp по значению

    }

    Но что если тип

    U
    не имеет бессбойной функции обмена, как в случае многих существующих классов, но вам требуется поддержка функции обмена для типа
    T
    ? Не все потеряно.

    • Если копирующий конструктор и оператор копирующего присваивания

    U
    не дают сбоев, то с объектами типа
    U
    вполне справится
    std::swap
    .

    • Если копирующий конструктор

    U
    может давать сбой, вы можете хранить (интеллектуальный) указатель на
    U
    вместо непосредственного члена. Указатели легко обмениваются. Следствием их применения являются дополнительные расходы на одно динамическое выделение памяти и дополнительную косвенность при обращении, но если вы храните все такие члены в едином Pimpl-объекте, то для всех закрытых членов дополнительные расходы вы понесете только один раз (см. рекомендацию 43).

    Никогда не пользуйтесь трюком реализации копирующего присваивания посредством копирующего конструирования с использованием непосредственного вызова деструктора и размещающего new, несмотря на то, что такой трюк регулярно "всплывает" в форумах, посвященных С++ (см. также рекомендацию 99). Так что никогда не пишите:

    T& T::operator=(const T& rhs) { // Плохо: анти-идиома

     if (this != &rhs) {

      this->~T();                   // плохая методика!

      new(this) T(rhs);             // (см. [Sutter00] §41)

     }

     return *this;

    }

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

    std::swap
    для ваших собственных нешаблонных типов:

    namespace std {

    template<> void swap(MyType& lhs, MyType& rhs) {

     lhs.swap(rhs); // Для объектов MyType используется

    } // MyType::swap

    }

    Стандарт не позволяет вам сделать это, если

    MyType
    сам является шаблонным классом. К счастью, иметь такую специализацию хорошо, но не обязательно; основная методика состоит в обеспечении функции
    swap
    , эффективно работающей с данным типом, в виде функции, не являющейся членом класса, в том же пространстве имен, в котором находится и ваш тип.

    Исключения

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

    Ссылки

    [C++03] §17.4.3.1(1) • [Stroustrup00] §E.3.3 • [Sutter00] §12-13, §41


    Примечания:



    2

    Nefarious — нечестивый, гнусный (англ.). — Прим. перев.









    Главная | В избранное | Наш E-MAIL | Добавить материал | Нашёл ошибку | Наверх