Definido en el encabezado 
template<classT,class... Args >
unique_ptr<T>make_unique( Args&&... args );
 (1) (desde C ++ 14)
(solo para noarray tipos)		 
template<classT>
unique_ptr<T>make_unique( std::size_t size );
 (2) (desde C ++ 14)
(solo para array tipos con límite desconocido)		 
template<classT,class... Args >/* unspecified */make_unique( Args&&... args )=delete;
 (3) (desde C ++ 14)
(solo para array tipos con límite conocido)		 
template<classT>
unique_ptr<T>make_unique_default_init();
 (4) (desde C ++ 20)
(solo para noarray tipos)		 
template<classT>
unique_ptr<T>make_unique_default_init( std::size_t size );
 (5) (desde C ++ 20)
(solo para array tipos con límite desconocido)		 
template<classT,class... Args >/* unspecified */make_unique_default_init( Args&&... args )=delete;
 (6) (desde C ++ 20)
(solo para array tipos con límite conocido)

Construye un objeto de tipo T y lo envuelve en un std::unique_ptr.

1) Construye un noarray escribe T. Los argumentos args se pasan al constructor de T. Esta sobrecarga solo participa en la resolución de la sobrecarga si T no es un array escribe. La función es equivalente a: 

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

2) Construye un array de destino desconocido T. Esta sobrecarga solo participa en la resolución de la sobrecarga si T es un array de límite desconocido. La función es equivalente a: 

unique_ptr<T>(newtypenamestd::remove_extent<T>::type[size]())

3,6) No se permite la construcción de matrices de enlace conocido.4) Igual que (1), excepto que el objeto se inicializa por defecto. Esta sobrecarga solo participa en la resolución de la sobrecarga si T no es un array escribe. La función es equivalente a: 

unique_ptr<T>(new T)

5) Igual que (2), excepto que el array está inicializado por defecto. Esta sobrecarga solo participa en la resolución de la sobrecarga si T es un array de límite desconocido. La función es equivalente a: 

unique_ptr<T>(newtypenamestd::remove_extent<T>::type[size])

Parámetros

argumentos – lista de argumentos con los que una instancia de T será construido.
Talla – el tamaño de la array para construir

Valor devuelto

std::unique_ptr de una instancia de tipo T.

Excepciones

Puede tirar std::bad_alloc o cualquier excepción lanzada por el constructor de T. Si se lanza una excepción, esta función no tiene ningún efecto.

Posible implementación

// note: this implementation does not disable this overload for array typestemplate<typenameT,typename... Args>
std::unique_ptr<T>make_unique(Args&&... args)return std::unique_ptr<T>(newT(std::forward<Args>(args)...));

Notas

diferente a std::make_shared (que tiene std::allocate_shared), std::make_unique no tiene una contraparte consciente del asignador. Hipotético allocate_unique sería necesario inventar el tipo de borrador D Para el unique_ptr devuelve que contendría un objeto asignador e invocaría a ambos destroy y deallocate en su operator().

Ejemplo

#include#includestructVec3int x, y, z;Vec3():x(0),y(0),z(0)Vec3(int x,int y,int z):x(x),y(y),z(z)friend std::ostream&operator<<(std::ostream& os, Vec3& v)return os <<''<<"x:"<< v.x <<" y:"<< v.y <<" z:"<< v.z  <<'';;intmain()// Use the default constructor.
    std::unique_ptr<Vec3> v1 = std::make_unique<Vec3>();// Use the constructor that matches these arguments
    std::unique_ptr<Vec3> v2 = std::make_unique<Vec3>(0,1,2);// Create a unique_ptr to an array of 5 elements
    std::unique_ptr<Vec3[]> v3 = std::make_unique<Vec3[]>(5);
 
    std::cout <<"make_unique():      "<<*v1 <<'n'<<"make_unique(0,1,2): "<<*v2 <<'n'<<"make_unique(5):   "<<'n';for(int i =0; i <5; i++)
        std::cout <<"     "<< v3[i]<<'n';

Producción:

make_unique<Vec3>():x:0 y:0 z:0
make_unique<Vec3>(0,1,2):x:0 y:1 z:2
make_unique<Vec3[]>(5):x:0 y:0 z:0x:0 y:0 z:0x:0 y:0 z:0x:0 y:0 z:0x:0 y:0 z:0

Ver también

(constructor) construye un nuevo unique_ptr
(función de miembro público)
make_sharedmake_shared_default_init(C ++ 20) crea un puntero compartido que administra un nuevo objeto
(plantilla de función)