std::make_unique

std::make_unique<T>(args...) — шаблонная функция, которая конструирует объект T с аргументами args... и оборачивает его в std::unique_ptr<T> за один выразительный вызов. Функционально она почти эквивалентна std::unique_ptr<T>(new T(args...)), но безопаснее в присутствии исключений — по причинам, разобранным в разделе «Как это работает под капотом».std::make_unique<T>(args...) is a template function that constructs a T object with arguments args... and wraps it in a std::unique_ptr<T> in one expressive call. Functionally it's almost equivalent to std::unique_ptr<T>(new T(args...)), but safer in the presence of exceptions — for reasons covered in "How it works under the hood."

auto w = std::unique_ptr<Widget>(new Widget(42));
// работает, но небезопасно в составе списка аргументов —// works, but unsafe as part of an argument list —
// см. секцию "Грабли"// see the "Gotchas" section

auto w = std::make_unique<Widget>(42);
// короче и исключительно-безопасно в любом контексте// shorter and exception-safe in any context

Отсутствие make_unique в C++11 — не осознанное архитектурное решение, а признанный самим комитетом недосмотр:The absence of make_unique in C++11 wasn't a deliberate design decision — it was an oversight the committee itself acknowledged:

make_unique устраняет опасность тем, что вся работа — выделение памяти оператором new, конструирование объекта и оборачивание результата в unique_ptr — происходит внутри одного вызова функции, до того как управление вернётся к вызывающему коду и продолжится вычисление остальных аргументов внешнего выражения. Раз new T(args...) и обёртка в unique_ptr — это одно неделимое с точки зрения вызывающего кода действие, между ними не может вклиниться исключение из соседнего аргумента.make_unique removes the danger because all the work — allocating memory with new, constructing the object, and wrapping the result in a unique_ptr — happens inside a single function call, before control returns to the calling code and evaluation of the outer expression's remaining arguments continues. Since new T(args...) and the unique_ptr wrapping are, from the caller's perspective, one indivisible action, an exception from a sibling argument can't wedge itself in between.

// упрощённая (но по сути верная) реализация make_unique для единичного объекта:// simplified (but essentially correct) implementation of make_unique for a single object:
template <class T, class... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// использование — неотличимо от вызова конструктора T напрямую:// usage — indistinguishable from calling T's constructor directly:
auto w = make_unique<Widget>(42, "label");

Обратите внимание: эта реализация опирается на variadic templates и perfect forwarding — оба механизма из C++11, и именно они делают возможным написать такую функцию самостоятельно, если приходится работать в C++11-окружении (см. cpp11/unique-ptr.html, где этот приём упомянут как обходной путь, и cpp11/variadic-templates.html для деталей механизма). Собственно C++14 не добавляет здесь ничего нового в язык — make_unique целиком реализуем средствами C++11, просто библиотека не включала его до C++14. Единственное отличие полной реализации стандартной библиотеки от приведённой — дополнительная перегрузка для массивов (make_unique<T[]>(size)) и явный запрет вызова с указанным размером массива известной длины на этапе компиляции.Note that this implementation relies on variadic templates and perfect forwarding — both C++11 mechanisms, and they're exactly what makes it possible to write such a function yourself if you have to work in a C++11 environment (see cpp11/unique-ptr.html, where this technique is mentioned as a workaround, and cpp11/variadic-templates.html for the mechanism's details). C++14 itself adds nothing new to the language here — make_unique is entirely implementable with C++11 facilities; the library simply didn't include it until C++14. The only difference between the full standard-library implementation and the one shown here is an additional overload for arrays (make_unique<T[]>(size)) and an explicit compile-time rejection of calls specifying a size for an array of already-known length.

• cppreference — std::make_unique
• WG21 N3588 — make_unique (Revision 1)