Відмінності між std :: make_unique та std :: unique_ptr з новими

Чи std::make_uniqueє якісь переваги ефективності, як std::make_shared?

Порівняно з ручним побудовою std::unique_ptr:

std::make_unique<int>(1);         // vs
std::unique_ptr<int>(new int(1));

Мотивація позаду make_uniqueнасамперед двояка:

• make_uniqueє безпечним для створення тимчасових періодів, тоді як при явному використанні newви повинні пам’ятати правило про невикористання безіменних темпорарій.

  foo(make_unique<T>(), make_unique<U>()); // exception safe
  
  foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*
  

• Додавання, make_uniqueнарешті, означає, що ми можемо сказати людям використовувати "ніколи", newа не попереднє правило, щоб "ніколи" використовувати, newза винятком випадків, коли ви робите unique_ptr".

Є також третя причина:

• make_uniqueне потребує надмірного використання типу. unique_ptr<T>(new T())->make_unique<T>()

Жодна з причин не передбачає підвищення ефективності виконання часу, як це використовується make_shared(завдяки уникненню другого розподілу, ціною потенційно більшого пікового використання пам'яті).

* Очікується, що C ++ 17 включить зміну правила, що означає, що це більше не є небезпечним. Дивіться документи C ++ комітетів P0400R0 та P0145R3 .

std::make_uniqueі std::make_sharedчи існують вони з двох причин:

1. Так що вам не доведеться чітко перераховувати аргументи типу шаблону.
2. Додатковий виняток безпеки щодо використання std::unique_ptrабо std::shared_ptrконструкторів. (Див. Розділ Примітки тут .)

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

Причина, чому вам доведеться використовувати std::unique_ptr(new A())або std::shared_ptr(new A())безпосередньо замість того std::make_*(), щоб не мати доступу до конструктора класу Aпоза поточним діапазоном.

Розглянемо виклик функції

void function(std::unique_ptr<A>(new A()), std::unique_ptr<B>(new B())) { ... }

Припустимо, що нове A()успішно, але нове B()викидає виняток: ви його вловлюєте для відновлення нормального виконання вашої програми. На жаль, стандарт C ++ не вимагає, щоб об’єкт A руйнувався і його пам'ять перерозподілялася: пам'ять мовчки просочується і немає способу її очистити. Загорнувши A і B, std::make_uniquesви впевнені, що витік не відбудеться:

void function(std::make_unique<A>(), std::make_unique<B>()) { ... }

Сенс у тому, що std::make_unique<A>і std::make_unique<B>зараз є тимчасовими об'єктами, і очищення тимчасових об'єктів правильно визначено в стандарті C ++: їх деструктори будуть спрацьовувати, а пам'ять буде звільнена. Тому, якщо можете, завжди віддайте перевагу виділенню об'єктів за допомогою std::make_uniqueта std::make_shared.