Namespaces
Variants

std::weak_ptr<T>:: 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
constexpr weak_ptr ( ) noexcept ;
(1) (desde C++11)
weak_ptr ( const weak_ptr & r ) noexcept ;
(2) (desde C++11)
template < class Y >
weak_ptr ( const weak_ptr < Y > & r ) noexcept ;
(2) (desde C++11)
template < class Y >
weak_ptr ( const std:: shared_ptr < Y > & r ) noexcept ;
(2) (desde C++11)
weak_ptr ( weak_ptr && r ) noexcept ;
(3) (desde C++11)
template < class Y >
weak_ptr ( weak_ptr < Y > && r ) noexcept ;
(3) (desde C++11)

Construye un nuevo weak_ptr que potencialmente comparte un objeto con r .

1) Constructor por defecto. Construye un weak_ptr vacío.
2) Construye un nuevo weak_ptr que comparte un objeto gestionado por r . Si r no gestiona ningún objeto, * this tampoco gestiona ningún objeto. Las sobrecargas plantilla no participan en la resolución de sobrecarga a menos que Y* sea convertible implícitamente a T* , o Y sea el tipo "array de N U " para algún tipo U y algún número N , y T sea el tipo "array de límite desconocido de (posiblemente calificado cv) U " (desde C++17) .
3) Constructores de movimiento. Mueve una instancia de weak_ptr desde r hacia * this . Después de esto, r está vacío y r. use_count ( ) == 0 . La sobrecarga plantilla no participa en la resolución de sobrecarga a menos que Y* sea implícitamente convertible a T* .

Contenidos

Parámetros

r - un std::shared_ptr o std::weak_ptr que será observado por este std::weak_ptr

Notas

Debido a que el constructor por defecto es constexpr , los std::weak_ptr estáticos se inicializan como parte de la inicialización no-local estática , antes de que comience cualquier inicialización no-local dinámica. Esto hace seguro usar un std::weak_ptr en el constructor de cualquier objeto estático.

Ejemplo

Ejecutar este código 
#include <iostream>
#include <memory>
struct Foo {};
int main()
{
    std::weak_ptr<Foo> w_ptr;
    {
        auto ptr = std::make_shared<Foo>();
        w_ptr = ptr;
        std::cout << "w_ptr.use_count() inside scope: " << w_ptr.use_count() << '\n';
    }
    std::cout << "w_ptr.use_count() out of scope: " << w_ptr.use_count() << '\n';
    std::cout << "w_ptr.expired() out of scope: "
              << std::boolalpha << w_ptr.expired() << '\n';
}

Salida: 

w_ptr.use_count() inside scope: 1
w_ptr.use_count() out of scope: 0
w_ptr.expired() out of scope: true

Informes de defectos

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

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 2315 C++11 la semántica de movimiento no estaba habilitada para weak_ptr habilitada

Véase también

asigna el weak_ptr
(función miembro pública)