std::make_unique

Defined in header `<memory>`
template< class T, class... Args > unique_ptr<T> make_unique( Args&&... args );	(1)	(since C++14) (only for non-array types)
template< class T > unique_ptr<T> make_unique( std::size_t size );	(2)	(since C++14) (only for array types with unknown bound)
template< class T, class... Args > /* unspecified */ make_unique( Args&&... args ) = delete;	(3)	(since C++14) (only for array types with known bound)

Constructs an object of type T and wraps it in a std::unique_ptr.

1) Constructs a non-array type T. The arguments args are passed to the constructor of T. This overload only participates in overload resolution if T is not an array type. The function is equivalent to:

unique_ptr<T>(new T(std::forward<Args>(args)...))

2) Constructs an array of unknown bound T. This overload only participates in overload resolution if T is an array of unknown bound. The function is equivalent to:

unique_ptr<T>(new typename std::remove_extent<T>::type[size]())

3) Construction of arrays of known bound is disallowed.

Parameters

args	-	list of arguments with which an instance of `T` will be constructed.
size	-	the size of the array to construct

Return value

std::unique_ptr of an instance of type T.

Exceptions

May throw std::bad_alloc or any exception thrown by the constructor of T. If an exception is thrown, this function has no effect.

Possible Implementation

// note: this implementation does not disable this overload for array types
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Notes

Unlike std::make_shared (which has std::allocate_shared), std::make_unique does not have an allocator-aware counterpart. A hypothetical allocate_unique would be required to invent the deleter type D for the unique_ptr<T,D> it returns which would contain an allocator object and invoke both destroy and deallocate in its operator().

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
Relational operators
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
`optional`, `any` and `variant` (C++17)
optional
any
variant
in_placein_place_typein_place_indexin_place_tin_place_type_tin_place_index_t
Pairs and tuples
pair
tuple (C++11)
apply (C++17)
make_from_tuple (C++17)
piecewise_construct_t (C++11)
piecewise_construct (C++11)
integer_sequence (C++14)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)

Member functions
unique_ptr::unique_ptr
unique_ptr::~unique_ptr
unique_ptr::operator=
Modifiers
unique_ptr::release
unique_ptr::reset
unique_ptr::swap
Observers
unique_ptr::get
unique_ptr::get_deleter
unique_ptr::operator bool
unique_ptr::operator*unique_ptr::operator->
unique_ptr::operator[]
Non-member functions
make_unique (C++14)
operator==operator!=operator<operator>operator<=operator>operator>=
std::swap
std::hash