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

 makeLogEntry(pw);
 delete pw;
};

std::unique_ptr<                 // Тип удалителя является
 Widget, decltype(loggingDel)    // частью типа указателя
> upw(new Widget, loggingDel);

std::shared_ptr          // Тип удалителя не является
spw(new Widget, loggingDel);     // частью типа указателя

Дизайн std::shared_ptr более гибок. Рассмотрим два указателя std::shared_ptr, каждый со своим пользовательским удалителем разных типов (например, из-за того, что пользовательские удалители определены с помощью лямбда-выражений):

auto customDeleter1 = [](Widget *pw) { … }; // Пользовательские
auto customDeleter2 = [](Widget *pw) { … }; // удалители
                                            // разных типов

std::shared_ptr pw1(new Widget, customDeleter1);
std::shared_ptr pw2(new Widget, customDeleter2);

Поскольку pw1 и pw2 имеют один и тот же тип, они могут быть помещены в контейнер объектов этого типа:

std::vector> vpw( pw1, pw2 };

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

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

А он и не может. Ему приходится использовать дополнительную память, но эта память не является частью объекта std::shared_ptr. Она располагается в динамической памяти или, если создатель std::shared_ptr воспользуется поддержкой со стороны std::shared_ptr пользовательских распределителей памяти, там, где выделит память такой распределитель. Ранее я отмечал, что объект std::shared_ptr содержит указатель на счетчик ссылок для объекта, на который он указывает. Это так, но это немного не так, поскольку счетчик ссылок является частью большей структуры данных, известной под названием управляющий блок (control block). Управляющий блок имеется для каждого объекта, управляемого указателями std::shared_ptr. Управляющий блок в дополнение к счетчику ссылок содержит копию пользовательского удалителя, если таковой был указан. Если указан пользовательский распределитель памяти, управляющий блок содержит и его копию. Управляющий блок может также содержать дополнительные данные, включающие, как поясняется в разделе 4.4, вторичный счетчик ссылок, известный как слабый счетчик, но в данном разделе мы его игнорируем. Мы можем представить память, связанную с объектом std::shared_ptr, как имеющую следующий вид:

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

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

• Управляющий блок создается тогда, когда указательstd::shared_ptrсоздается из указателя с исключительным владением (т.e.std::unique_ptrилиstd::auto_ptr). Указатели с исключительным владением не используют управляющие блоки, так что никакого управляющего блока для указываемого объекта не существует. (Как часть своего построения std::shared_ptr осуществляет владение указываемым объектом, так что указатель с исключительным владением становится нулевым.)

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

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