Namespaces
Variants

std:: weak_ptr

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
Definido en el encabezado <memory>
template < class T > class weak_ptr ;
(desde C++11)

std::weak_ptr es un puntero inteligente que mantiene una referencia no propietaria ("débil") a un objeto gestionado por std::shared_ptr . Debe convertirse a std::shared_ptr para acceder al objeto referenciado.

std::weak_ptr modela la propiedad temporal: cuando un objeto necesita ser accedido solo si existe, y puede ser eliminado en cualquier momento por otro componente, std::weak_ptr se utiliza para rastrear el objeto, y se convierte a std::shared_ptr para adquirir propiedad temporal. Si el std::shared_ptr original es destruido en este momento, el tiempo de vida del objeto se extiende hasta que el std::shared_ptr temporal también sea destruido.

Otro uso para std::weak_ptr es romper ciclos de referencias formados por objetos gestionados por std::shared_ptr . Si dicho ciclo queda huérfano (es decir, no hay punteros compartidos externos al ciclo), los shared_ptr no pueden alcanzar un contador de referencias cero y la memoria tiene una fuga. Para prevenir esto, uno de los punteros en el ciclo puede hacerse débil .

Contenidos

Tipos de miembros

Tipo de miembro Definición
element_type

T

(hasta C++17)

std:: remove_extent_t < T >

(desde C++17)

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 propiedad 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 fue eliminado
(función miembro pública)
crea un shared_ptr que gestiona el objeto referenciado
(función miembro pública)
proporciona ordenamiento basado en propietario de punteros débiles
(función miembro pública)
(C++26)
proporciona hashing basado en propietario de punteros débiles
(función miembro pública)
(C++26)
proporciona comparación de igualdad basada en propietario de punteros débiles
(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_ptr del cual fue construido.

Es necesario un puntero almacenado separado para garantizar que convertir un shared_ptr a weak_ptr y luego volver funcione correctamente, incluso para shared_ptr s con alias. No es posible acceder al puntero almacenado en un weak_ptr sin bloquearlo en un shared_ptr .

Macro de prueba de características Valor Std Característica
__cpp_lib_smart_ptr_owner_equality 202306L (C++26) Habilitar el uso de std::weak_ptr como claves en contenedores asociativos no ordenados

Ejemplo

Demuestra cómo se utiliza lock para garantizar la validez del puntero.

Ejecutar este código 
#include <iostream>
#include <memory>
std::weak_ptr<int> gw;
void observe()
{
    std::cout << "gw.use_count() == " << gw.use_count() << "; ";
    // we have to make a copy of shared pointer before usage:
    if (std::shared_ptr<int> spt = gw.lock())
        std::cout << "*spt == " << *spt << '\n';
    else
        std::cout << "gw is expired\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 is expired

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3001 C++17 element_type no se actualizó para soporte de arrays actualizado

Véase también

(C++11)
puntero inteligente con semántica de propiedad única de objetos
(plantilla de clase)
(C++11)
puntero inteligente con semántica de propiedad compartida de objetos
(plantilla de clase)