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

Construit un nouveau weak_ptr qui partage potentiellement un objet avec r .

1) Constructeur par défaut. Construit un weak_ptr vide.
2) Construit un nouveau weak_ptr qui partage un objet géré par r . Si r ne gère aucun objet, * this ne gère aucun objet non plus. Les surcharges template ne participent pas à la résolution de surcharge sauf si Y* est implicitement convertible en T* , ou Y est le type "tableau de N U " pour un certain type U et un certain nombre N , et T est le type "tableau de limite inconnue de (éventuellement qualifié cv) U " (depuis C++17) .
3) Constructeurs de déplacement. Déplace une instance de weak_ptr de r vers * this . Après cette opération, r est vide et r. use_count ( ) == 0 . La surcharge template ne participe pas à la résolution de surcharge sauf si Y* est implicitement convertible en T* .

Table des matières

Paramètres

r - un std::shared_ptr ou std::weak_ptr qui sera visualisé par ce std::weak_ptr

Notes

Parce que le constructeur par défaut est constexpr , les std::weak_ptr statiques sont initialisés dans le cadre de l'initialisation non-locale statique , avant que toute initialisation non-locale dynamique ne commence. Cela rend sûr d'utiliser un std::weak_ptr dans le constructeur de tout objet statique.

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 2315 C++11 la sémantique de déplacement n'était pas activée pour weak_ptr activée

Voir aussi

assigne le weak_ptr
(fonction membre publique)