std::weak_ptr

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.

[editar] Tipos miembro

[editar] Funciones miembro

[editar] Funciones no miembro

[editar] Clases auxiliares

[editar] Guías de deducción (desde C++17)

[editar] 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_ptr a 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.

[editar] Ejemplo

#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();
}

gw.use_count() == 1; *spt == 42
gw.use_count() == 0; gw ha expirado

[editar] 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.

[editar] Véase también