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

Функции std::make_uniqueи std::make_sharedпредставляют собой две из трех make -функций , т.e. функций, которые принимают произвольное количество аргументов, выполняют их прямую передачу конструктору объекта, создаваемого в динамической памяти, и возвращают интеллектуальный указатель на этот объект. Третья mаkе-функция — std::allocate_shared. Она работает почти так же, как и std::make_shared, за исключением того, что первым аргументом является объект распределителя, использующийся для выделения динамической памяти.

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

auto upw1(std::make_unique< Widget>()); // С mаkе-функцией

std::unique_ptr< Widget> upw2(new Widget); // Без make-функции

auto spw1(std::make_shared< Widget>()); // С make-функцией

std::shared_ptr< Widget> spw2(new Widget); // Без make-функции

Я подчеркнул важное отличие: версия с применением оператора newповторяет созданный тип, в то время как mаkе-функции этого не делают. Повторение типа идет вразрез с основным принципом разработки программного обеспечения: избегать дублирования кода. Дублирование в исходном тексте увеличивает время компиляции, может вести к раздутому объектному коду и в общем случае приводит к коду, с которым сложно работать. Зачастую это ведет к несогласованному коду, а несогласованности в коде часто ведут к ошибкам. Кроме того, чтобы набрать на клавиатуре что-то дважды, надо затратить в два раза больше усилий, чем для единственного набора, а кто из нас не любит сократить эту работу?

Второй причиной для предпочтения mаkе-функций является безопасность исключений. Предположим, что у нас есть функция для обработки Widgetв соответствии с некоторым приоритетом:

void processWidget(std::shared_ptr spw, int priority);

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

Предположим теперь, что у нас есть функция для вычисления приоритета

int computePriority();

и мы используем ее в вызове processWidget, который использует оператор newвместо std::make_shared:

processWidget( // Потенциальная

std::shared_ptr(new Widget), // утечка

computePriority()); // ресурса

Как указывает комментарий, этот код может приводить к утечке Widget, вызванной применением new. Но почему? И вызывающий код, и вызываемая функция используют указатели std::shared_ptr, а std::shared_ptrспроектированы для предотвращения утечек ресурсов. Они автоматически уничтожают то, на что указывают, когда исчезает последний std::shared_ptr. Если все везде используют указатели std::shared_ptr, о какой утечке может идти речь?

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

• Выражение new Widgetдолжно быть вычислено, т.e. в динамической памяти должен быть создан объект Widget.

• Должен быть вызван конструктор std::shared_ptr, отвечающий за управление указателем, сгенерированным оператором new.

• Должна быть вызвана функция computePriority.

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

1. Выполнить new Widget.

2. Выполнить computePriority.

3. Вызвать конструктор std::shared_ptr.

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

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

processWidget( std::make_shared(), // Потенциальной

computePriority()); // утечки ресурсов нет

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

Если мы заменим std::shared_ptrи std::make_sharedуказателем std::unique_ptrи функцией std::make_unique,все приведенные рассуждения останутся в силе. Использование std::make_uniqueвместо newтак же важно для написания безопасного с точки зрения исключений кода, как и применение std::make_shared.

Особенностью std::make_shared(по сравнению с непосредственным использованием new) является повышенная эффективность. Применение std::make_sharedпозволяет компиляторам генерировать меньший по размеру и более быстрый код, использующий более компактные структуры данных. Рассмотрим следующее непосредственное применение оператора new:

std::shared_ptr spw(new Widget);

Очевидно, что этот код предполагает выделение памяти, но фактически он выполняет два выделения. В разделе 4.2 поясняется, что каждый указатель std::shared_ptrуказывает на управляющий блок, содержащий, среди прочего, значение счетчика ссылок для указываемого объекта. Память для этого блока управления выделяется в конструкторе std::shared_ptr. Непосредственное применение оператора new, таким образом, требует одного выделения памяти для Widgetи второго — для управляющего блока.

Если вместо этого использовать std::make_shared,

auto spw = std::make_shared();

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