Clase unique_ptr
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.
Sintaxis
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
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 de la biblioteca estándar de C++.
Use la función del asistente 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 más información, vea Declarador de referencia a un 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 ptr que apunta está asignado con newy que se puede liberar llamando a delete _Ptr. (Una especialización unique_ptr<T[]>parcial administra los objetos de matriz asignados con new[]y tiene el valor predeterminado deleter default_delete<T[]>, especializado para llamar delete[] ptra ).
El puntero almacenado en un recurso propio, stored_ptr tiene el tipo pointer. Es Del::pointer si se define y T * si no se define. El objeto almacenado deleterstored_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
| Nombre | Descripción |
|---|---|
unique_ptr |
Hay siete constructores de unique_ptr. |
Typedefs
| Nombre | Descripción |
|---|---|
deleter_type |
Sinónimo del parámetro de plantilla Del. |
element_type |
Sinónimo del parámetro de plantilla T. |
pointer |
Sinónimo de Del::pointer si se define, si no T *. |
Funciones
| Nombre | Descripción |
|---|---|
get |
Devuelve stored_ptr. |
get_deleter |
Devuelve una referencia a stored_deleter. |
release |
Almacena pointer() en stored_ptr y devuelve su contenido anterior. |
reset |
Libera el recurso actualmente en propiedad y acepta un nuevo recurso. |
swap |
Intercambia el recurso y deleter con el unique_ptr proporcionado. |
Operadores
| Nombre | Descripción |
|---|---|
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. |
operator= |
Asigna el valor de unique_ptr (o un pointer-type) al unique_ptr actual. |
deleter_type
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.
element_type
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.
get
Devuelve stored_ptr.
pointer get() const;
Comentarios
La función miembro devuelve stored_ptr.
get_deleter
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.
operator=
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 llaman a reset(right.release()) mueven right.stored_deleter a stored_deleter y después devuelven *this.
pointer
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 *.
release
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();
}
Constructing Sample(3)
Constructing Sample(42)
Deleting Sample(42)
Deleting Sample(3)
reset
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
ptr
Puntero al recurso del que tomar posesión.
Comentarios
Use reset para cambiar el pointer almacenado propiedad de unique_ptr a ptr y, luego, eliminar el puntero almacenado original. Si 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.
swap
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.
unique_ptr
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
ptr
Puntero al recurso que se va a asignar a un unique_ptr.
_Deleter
deleter que se asignará a un unique_ptr.
right
rvalue 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.release() en stored_ptr y colocan right.get_deleter() dentro de stored_deleter.
~unique_ptr
El destructor de unique_ptr destruye un objeto unique_ptr.
~unique_ptr();
Comentarios
El destructor llama a get_deleter()(stored_ptr).