unique_ptr (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Almacena un puntero a un objeto o matriz en propiedad. El objeto o matriz no es propiedad de ningún otro unique_ptr. El objeto o matriz se destruye cuando unique_ptr se destruye.

class unique_ptr {  
   public:  
   unique_ptr();
   unique_ptr(nullptr_t Nptr);
   explicit unique_ptr(pointer Ptr);
   unique_ptr(pointer Ptr,  
   typename conditional<is_reference<Del>::value, Del,  
   typename add_reference<const Del>::type>::type Deleter);
   unique_ptr (pointer Ptr,  
   typename remove_reference<Del>::type&& Deleter);
   unique_ptr (unique_ptr&& Right);
   template <class T2, Class Del2>  
   unique_ptr(unique_ptr<T2, Del2>&& Right);
   unique_ptr(const unique_ptr& Right) = delete;  
   unique_ptr& operator=(const unique_ptr& Right) = delete;  
   };  

//Specialization for arrays:  
template <class T, class D>  
class unique_ptr<T[], D> {   public:          typedef pointer;  
    typedef T element_type;  
    typedef D deleter_type;  
    constexpr unique_ptr() noexcept;  
    template <class U>  
explicit unique_ptr(U p) noexcept;  
    template <class U>  
unique_ptr(U p, see below d) noexcept;  
    template <class U>  
unique_ptr(U p, see below d) noexcept;  
    unique_ptr(unique_ptr&& u) noexcept;  
    constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }     template <class U, class E>  
unique_ptr(unique_ptr<U, E>&& u) noexcept;  
 ~unique_ptr();
unique_ptr& operator=(unique_ptr&& u) noexcept;  
    template <class U, class E>  
unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;  
    unique_ptr& operator=(nullptr_t) noexcept;  
    T& operator[](size_t i) const;

 
    pointer get() const noexcept;  
    deleter_type& get_deleter() noexcept;  
    const deleter_type& get_deleter() const noexcept;  
    explicit operator bool() const noexcept;  
    pointer release() noexcept;  
    void reset(pointer p = pointer()) noexcept;  
    void reset(nullptr_t = nullptr) noexcept;  
    template <class U>  
void reset(U p) noexcept = delete;  
    void swap(unique_ptr& u) noexcept;  // disable copy from lvalue unique_ptr(const unique_ptr&) = delete;  
    unique_ptr& operator=(const unique_ptr&) = delete;  
 };  
 }  

Parámetros

Right
Objeto unique_ptr.

Nptr
Interfaz rvalue cuyo tipo es std::nullptr_t.

Ptr
Objeto pointer.

Deleter
Una función deleter enlazada a unique_ptr.

unique_ptr no produce ninguna excepción.

La clase unique_ptr reemplaza a auto_ptr y se puede usar como un elemento de los contenedores STL.

Utilice la make_unique función auxiliar para crear eficazmente nuevas instancias de unique_ptr.

unique_ptr administra de forma única un recurso. Cada objeto unique_ptr almacena un puntero al objeto que posee o almacena un puntero null. Un recurso puede ser propiedad de no más de un unique_ptr de objeto; Cuando un unique_ptr se destruye el objeto que posee un recurso determinado, se libera el recurso. Un unique_ptr objeto se puede mover, pero no se copian; Para obtener más información, consulte declarador de referencia Rvalue: &&.

El recurso se libera llamando a un objeto almacenado deleter de tipo Del que sabe cómo se asignan los recursos de un unique_ptr determinado. El valor predeterminado deleter``default_delete``<T> supone que el recurso al que apunta ptr se asigna con new, y que se puede liberar llamando a delete _``Ptr. (Una especialización parcial unique_ptr<T[]>administra los objetos de matriz asignados con new[], y tiene el valor predeterminado deleter``default_delete<T[]>, especializado en llamar a delete [] ptr.)

El puntero almacenado en un recurso propio, stored_ptr tiene el tipo pointer. Es Del::pointer si definido, y T * si no es así. El objeto almacenado deleter stored_deleter no ocupa ningún espacio en el objeto si deleter no tiene estado. Observe que Del puede ser un tipo de referencia.

Constructores

unique_ptr:: unique_ptrHay siete constructores de unique_ptr.

Definiciones de tipo

deleter_typeSinónimo del parámetro de plantilla Del.
ELEMENT_TYPEUn sinónimo para el parámetro de plantillaT``.
punteroSinónimo de Del::pointer si se define, si no T *.

Funciones miembro

unique_ptr:: GetDevuelve stored_ptr.
unique_ptr:: get_deleterDevuelve una referencia a stored_deleter.
unique_ptr:: ReleaseAlmacena pointer() en stored_ptr y devuelve su contenido anterior.
unique_ptr:: ResetLibera el recurso actualmente en propiedad y acepta un nuevo recurso.
unique_ptr:: swapIntercambia el recurso y deleter con el unique_ptr proporcionado.

Operadores

operator boolEl operador devuelve un valor de un tipo que pueda convertirse en bool. El resultado de la conversión en bool es true cuando get() != pointer(), si no false.
operator->La función miembro devuelvestored_ptr``.
operator*Miembro función devuelve *stored_ptr``.
unique_ptr operator =Asigna el valor de un unique_ptr (o pointer-type) actual unique_ptr.

Encabezado:<>>

Espacio de nombres: std

El tipo es un sinónimo del parámetro de plantilla Del.

typedef Del deleter_type;  

Comentarios

El tipo es un sinónimo del parámetro de plantilla Del.

El tipo es un sinónimo del parámetro de plantilla Type.

typedef Type element_type;  

Comentarios

El tipo es un sinónimo del parámetro de plantilla Ty.

Devuelve stored_ptr.

pointer get() const;

Comentarios

La función miembro devuelve stored_ptr.

Devuelve una referencia a stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

Comentarios

La función miembro devuelve una referencia a stored_deleter.

Asigna la dirección del unique_ptr proporcionado al actual.

unique_ptr& operator=(
    unique_ptr&& right);

template <class U, Class Del2>  
unique_ptr& operator=(
    unique_ptr<Type, Del>&& right);

unique_ptr& operator=(
    pointer-type);

Parámetros

Referencia unique_ptr usada para asignar el valor correspondiente al unique_ptr actual.

Comentarios

Las funciones miembro llamada reset(`` right``.release()) y mover right``.stored_deleter a stored_deleter, devuelva *this.

Sinónimo de Del::pointer si se define, si no Type *.

typedef T1 pointer;  

Comentarios

Tipo sinónimo de Del::pointer si se define; de lo contrario, es Type *.

Libera la propiedad del puntero almacenado devuelto al llamador y establece el valor del puntero almacenado en nullptr.

pointer release();

Comentarios

Use release para asumir la propiedad del puntero sin formato almacenado por unique_ptr. El llamador es responsable de la eliminación del puntero devuelto. unique-ptr se establece en el estado vacío construido de forma predeterminada. Puede asignar otro puntero de tipo compatible al valor unique_ptr después de la llamada a release.

Ejemplo

Este ejemplo muestra cómo el llamador de versión es responsable del objeto devuelto:

// stl_release_unique.cpp  
// Compile by using: cl /W4 /EHsc stl_release_unique.cpp  
#include <iostream>  
#include <memory>  
  
struct Sample {  
   int content_;  
   Sample(int content) : content_(content) {  
      std::cout << "Constructing Sample(" << content_ << ")" << std::endl;  
   }  
   ~Sample() {  
      std::cout << "Deleting Sample(" << content_ << ")" << std::endl;  
   }  
};  
  
void ReleaseUniquePointer() {  
   // Use make_unique function when possible.    
   auto up1 = std::make_unique<Sample>(3);  
   auto up2 = std::make_unique<Sample>(42);  
  
   // Take over ownership from the unique_ptr up2 by using release  
   auto ptr = up2.release();  
   if (up2) {  
      // This statement does not execute, because up2 is empty.  
      std::cout << "up2 is not empty." << std::endl;  
   }  
   // We are now responsible for deletion of ptr.  
   delete ptr;  
   // up1 deletes its stored pointer when it goes out of scope.     
}  
  
int main() {  
   ReleaseUniquePointer();  
}  

Salida del equipo:

Constructing Sample(3)  
Constructing Sample(42)  
Deleting Sample(42)  
Deleting Sample(3)  
  

Toma posesión del parámetro de puntero y, luego, elimina el puntero almacenado original. Si el nuevo puntero es el mismo que el puntero almacenado original, reset elimina el puntero y establece el puntero almacenado en nullptr.

void reset(pointer ptr = pointer());

void reset(nullptr_t ptr);

Parámetros

ParámetroDescripción
ptrPuntero al recurso del que tomar posesión.

Comentarios

Utilice reset para cambiar el puntero pertenecen a la unique_ptr a ptr y, a continuación, elimine el puntero almacenado original. Si el unique_ptr no estaba vacío, reset invoca la función eliminadora devuelta por get_deleter en el puntero almacenado original.

Como reset almacena en primer lugar el nuevo puntero ptr y, después, elimina el puntero almacenado original, es posible que reset elimine de forma inmediata ptr si es el mismo que el puntero almacenado original.

Intercambia los punteros entre dos objetos unique_ptr.

void swap(unique_ptr& right);

Parámetros

right
unique_ptr usado para intercambiar punteros.

Comentarios

La función miembro cambia stored_ptr por right.stored_ptr y stored_deleter por right.stored_deleter.

Hay siete constructores de unique_ptr.

unique_ptr();

unique_ptr(nullptr_t);

explicit unique_ptr(
    pointer ptr);

unique_ptr(
    Type* ptr,  
    typename conditional<
    is_reference<Del>::value, 
    Del, 
    typename add_reference<const Del>::type>::type _Deleter);

unique_ptr(
    pointer ptr,  
    typename remove_reference<Del>::type&& _Deleter);

unique_ptr(
    unique_ptr&& right);

template <class Ty2, Class Del2>  
unique_ptr(
 unique_ptr<Ty2, Del2>&& right);

Parámetros

ParámetroDescripción
ptrPuntero al recurso que se va a asignar a un unique_ptr..
_Deleterdeleter que se asignará a un unique_ptr.
rightrvalue reference a un unique_ptr desde el que los campos unique_ptr se asignan al unique_ptr recién construido.

Comentarios

Los dos primeros constructores construyen un objeto que no administra ningún recurso. El tercer constructor almacena ptr en stored_ptr. El cuarto constructor almacena ptr en stored_ptr y deleter en stored_deleter.

El quinto constructor almacena ptr en stored_ptr y coloca deleter dentro de stored_deleter. El sexto y el séptimo constructor almacenan right.reset() en stored_ptr y colocan right.get_deleter() dentro de stored_deleter.

El destructor de unique_ptr destruye un objeto unique_ptr.

~unique_ptr();

Comentarios

El destructor llama a get_deleter()(stored_ptr).

<>>

Mostrar: