unique_ptr (Clase)

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

template< class Type, class Del = default_delete<Type> >
    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 Type2, Class Del2> unique_ptr( unique_ptr<Type2, Del2>&& Right );
    unique_ptr( const unique_ptr& Right) = delete;
    unique_ptr& operator=(const unique_ptr& Right ) = delete;
};

Parámetros

• Right
  unique_ptr.

• Nptr
  Interfaz rvalue cuyo tipo es std::nullptr_t.

• Ptr
  pointer.

• Deleter
  Una función deleter enlazada a unique_ptr.

Excepciones

unique_ptr no produce ninguna excepción.

Comentarios

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

Use la función auxiliar make_unique 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 no puede ser propiedad de más de un objeto unique_ptr; cuando se destruye un objeto unique_ptr que posee un recurso determinado, se libera el recurso. Un objeto unique_ptr se puede mover, pero no se puede copiar; para obtener más información, vea Declarador de referencia a un valor R: &&.

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 objeto deleter predeterminado default_delete<Type> 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<Type[]>**administra los objetos de matriz asignados con new[], y tiene el deleter default_delete<Type[]> predeterminado, especializado en llamar a delete[] _Ptr.)

El puntero almacenado en un recurso propio, stored_ptr tiene el tipo pointer. Es Del::pointer si se define y Type * si no se define. 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.

Miembros

Constructores

unique_ptr::unique_ptr

Hay siete constructores de unique_ptr.

Typedefs

deleter_type	Sinónimo del parámetro de plantilla Del.
element_type	Sinónimo del parámetro de plantilla Type.
puntero	Sinónimo de Del::pointer si se define, si no Type *.

Funciones miembro

unique_ptr::get	Devuelve stored_ptr.
unique_ptr::get_deleter	Devuelve una referencia a stored_deleter.
unique_ptr::release	Almacena pointer() en stored_ptr y devuelve su contenido anterior.
unique_ptr::reset	Libera el recurso actualmente en propiedad y acepta un nuevo recurso.
unique_ptr::swap	Intercambia el recurso y deleter con el unique_ptr proporcionado.

Operadores

operator bool	El 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 devuelve stored_ptr.
operator*	La función miembro devuelve*stored_ptr.
unique_ptr operator=	Asigna el valor de unique_ptr (o un pointer-type) al unique_ptr actual.

Requisitos

Encabezado: <memory>

Espacio de nombres: std

Vea también

Referencia

<memory>

Otros recursos

miembros unique_ptr