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

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

auto pw= new Widget; // pw - обычный указатель

…

std::shared_ptr

spw1( pw, loggingDel); // Создание управляющего блока для *pw

…

std::shared_ptr // Создание второго

spw2( pw, loggingDel); // управляющего блока для *pw!

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

Далее вызывается конструктор для spw1, которому передается обычный указатель, так что этот конструктор создает управляющий блок (и тем самым счетчик ссылок) для того, на что он указывает. В данном случае это *pw(т.e. объект, на который указывает pw). Само по себе это не является чем-то страшным, но далее с тем же обычным указателем вызывается конструктор для spw2, и он также создает управляющий блок (а следовательно, и счетчик ссылок) для *pw. Объект *pw, таким образом, имеет два счетчика ссылок, каждый из которых в конечном итоге примет нулевое значение, и это обязательно приведет к попытке уничтожить объект *pwдважды. Второе уничтожение и будет ответственно за неопределенное поведение.

Из этого можно вынести как минимум два урока, касающиеся применения std::shared_ptr. Во-первых, пытайтесь избегать передачи обычных указателей конструктору std::shared_ptr. Обычной альтернативой этому является применение функции std::make_shared(см. раздел 4.4), но в примере выше мы использовали пользовательские удалители, а это невозможно при использовании std::make_shared. Во-вторых, если вы вынуждены передавать обычный указатель конструктору std::shared_ptr, передавайте непосредственно результат оператора new, а не используйте переменную в качестве посредника. Если первую часть кода переписать следующим образом,

std::shared_ptr

spw1( new Widget, // Непосредственное использование new

loggingDel);

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

std::shared_ptr // spw2 использует тот же

spw2( spw1); // управляющий блок, что и spw1

Особенно удивительный способ, которым применение переменных с обычными указателями в качестве аргументов конструкторов std::shared_ptrможет привести к множественным управляющим блокам, включает указатель this. Предположим, что наша программа использует указатели std::shared_ptrдля управления объектами Widgetи у нас есть структура данных, которая отслеживает объекты Widget, которые были обработаны:

std::vector< std::shared_ptr> processedWidgets;

Далее, предположим, что Widgetимеет функцию-член, выполняющую эту обработку:

class Widget {

public:

…

void process();

};

Вот вполне разумно выглядящий подход к написанию Widget::process:

void Widget::process() {

… // Обработка Widget

processedWidgets.emplace_back( this); // Добавление в список

} // обработанных Widget;

// это неправильно!

Комментарий о неправильности кода относится не к использованию emplace_back, а к передаче thisв качестве аргумента. (Если вы не знакомы с emplace_back, обратитесь к разделу 8.2.) Этот код будет компилироваться, но он передает обычный указатель ( this) контейнеру указателей std::shared_ptr. Конструируемый таким образом указатель std::shared_ptrбудет создавать новый управляющий блок для указываемого Widget(т.e. для объекта *this). Это не выглядит ужасным до тех пор, пока вы не понимаете, что, если имеются указатели std::shared_ptrвне функции-члена, которые уже указывают на этот объект Widget, вам не избежать неопределенного поведения.

API std::shared_ptrвключает средство для ситуаций такого рода. Вероятно, его имя — наиболее странное среди всех имен стандартной библиотеки: std::enable_shared_from_this. Это шаблон базового класса, который вы наследуете, если хотите, чтобы класс, управляемый указателями std::shared_ptr, был способен безопасно создавать std::shared_ptrиз указателя this. В нашем примере Widgetбудет унаследован от std::enable_shared_from_thisследующим образом:

class Widget: public std::enable_shared_from{

public:

…

void process();

};

Как я уже говорил, std::enable_shared_from_thisявляется шаблоном базового класса. Его параметром типа всегда является имя производного класса, так что класс Widgetпорождается от std::enable_shared_from_this. Если идея производного класса, порожденного от базового класса, шаблонизированного производным, вызывает у вас головную боль, попытайтесь об этом не думать. Этот код совершенно законный, а соответствующий шаблон проектирования хорошо известен, имеет стандартное имя, хотя и почти такое же странное, как std::enable_shared_from_this. Это имя — Странно повторяющийся шаблон ( The Curiously Recurring Template Pattern — CRTP ). Если вы хотите узнать о нем побольше, расчехлите свой поисковик, поскольку сейчас мы возвращаемся к нашему барану по имени std::enable_shared_from_this.

Шаблон std::enable_shared_from_thisопределяет функцию-член, которая создает std::shared_ptrдля текущего объекта, но делает это, не дублируя управляющие блоки. Это функция-член shared_from_this, и вы должны использовать ее в функциях-членах тогда, когда вам нужен std::shared_ptr, который указывает на тот же объект, что и указатель this. Вот как выглядит безопасная реализация Widget::process:

void Widget::process() {

// Как и ранее, обработка Widget

…

// Добавляем std::shared_ptr, указывающий на

// текущий объект, в processedWidgets