std::weak_ptr
| Definido en el archivo de encabezado <memory>
|
||
template< class T > class weak_ptr; |
(desde C++11) | |
std::weak_ptr es un puntero inteligente que contiene una referencia de no posesión ("débil") a un objeto que es gestionado por std::shared_ptr. Debe convertirse a std::shared_ptr para poder acceder al objeto referenciado.
std::weak_ptr modela la posesión temporal: cuando un objeto necesita ser accedido solo si existe, y puede ser eliminado en cualquier momento por alguien más, se usa std::weak_ptr para rastrear el objeto, y se convierte a std::shared_ptr para asumir la posesión temporal. Si el std::shared_ptr original se destruye en este momento, el tiempo de vida del objeto se extiende hasta que el std::shared_ptr temporal también se destruya.
Otro uso para std::weak_ptr es romper ciclos de referencia formados por objetos gestionados por std::shared_ptr. Si dicho ciclo queda huérfano (es decir, no hay punteros externos compartidos en el ciclo), los conteos de referencia de shared_ptr no pueden llegar a cero y se genera una fuga de memoria. Para evitar esto, uno de los punteros del ciclo se puede hacer débil.
Tipos miembro
| Tipo miembro | Definición | ||||
element_type
|
|
Funciones miembro
Crea un nuevo weak_ptr. (función miembro pública) | |
Destruye un weak_ptr. (función miembro pública) | |
Asigna el weak_ptr. (función miembro pública) | |
Modificadores | |
| Libera la posesión del objeto gestionado. (función miembro pública) | |
| Intercambia los objetos gestionados. (función miembro pública) | |
Observadores | |
Devuelve el número de objetos shared_ptr que gestionan el objeto. (función miembro pública) | |
| Comprueba si el objeto referenciado ya ha sido eliminado. (función miembro pública) | |
Crea un shared_ptr que gestiona el objeto referenciado. (función miembro pública) | |
| Proporciona ordenamiento de punteros débiles basado en propietario. (función miembro pública) | |
Funciones no miembro
(C++11) |
Especializa el algoritmo std::swap. (plantilla de función) |
Clases auxiliares
(C++20) |
Puntero débil atómico. (especialización de plantilla de clase) |
Guías de deducción (desde C++17)
Notas
Al igual que std::shared_ptr, una implementación típica de weak_ptr almacena dos punteros:
- un puntero al bloque de control; y
- el puntero almacenado del
shared_ptra partir del cual se construyó.
Es necesario un puntero almacenado por separado para garantizar que la conversión de un shared_ptr a weak_ptr y luego de regreso funcione correctamente, incluso para shared_ptrs con alias. No es posible acceder al puntero almacenado en un weak_ptr sin bloquearlo en un shared_ptr.
Ejemplo
Demuestra cómo se usa el bloqueo para garantizar la validez del puntero.
#include <iostream>
#include <memory>
std::weak_ptr<int> gw;
void observe()
{
std::cout << "gw.use_count() == " << gw.use_count() << "; ";
// tenemos que hacer una copia del puntero compartido antes de su uso:
if (std::shared_ptr<int> spt = gw.lock()) {
std::cout << "*spt == " << *spt << '\n';
}
else {
std::cout << "gw ha expirado\n";
}
}
int main()
{
{
auto sp = std::make_shared<int>(42);
gw = sp;
observe();
}
observe();
}
Salida:
gw.use_count() == 1; *spt == 42
gw.use_count() == 0; gw ha expirado
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 3001 | C++17 | element_type no se actualizaba para apoyo de arrays.
|
Se actualizó. |
Véase también
(C++11) |
Puntero inteligente con semántica de posesión de objeto única. (plantilla de clase) |
(C++11) |
Puntero inteligente con semántica de posesión de objeto compartida. (plantilla de clase) |