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
~weak_ptr ( ) ;
(depuis C++11)

Détruit l'objet weak_ptr . N'a aucun effet sur l'objet géré.

Exemple

Le programme montre l'effet de "non-rupture" du cycle des std::shared_ptr s.

Exécuter ce code 
#include <iostream>
#include <memory>
#include <variant>
class Node
{
    char id;
    std::variant<std::weak_ptr<Node>, std::shared_ptr<Node>> ptr;
public:
    Node(char id) : id{id} {}
    ~Node() { std::cout << "  '" << id << "' récupéré\n"; }
    /*...*/
    void assign(std::weak_ptr<Node> p) { ptr = p; }
    void assign(std::shared_ptr<Node> p) { ptr = p; }
};
enum class shared { all, some };
void test_cyclic_graph(const shared x)
{
    auto A = std::make_shared<Node>('A');
    auto B = std::make_shared<Node>('B');
    auto C = std::make_shared<Node>('C');
    A->assign(B);
    B->assign(C);
    if (shared::all == x)
    {
        C->assign(A);
        std::cout << "All links are shared pointers";
    }
    else
    {
        C->assign(std::weak_ptr<Node>(A));
        std::cout << "One link is a weak_ptr";
    }
    /*...*/
    std::cout << "\nLeaving...\n";
}
int main()
{
    test_cyclic_graph(shared::some);
    test_cyclic_graph(shared::all); // produit une fuite de mémoire
}

Sortie : 

One link is a weak_ptr
Leaving...
  'A' récupéré
  'B' récupéré
  'C' récupéré
All links are shared pointers
Leaving...

Voir aussi

détruit l'objet possédé si aucun autre shared_ptr ne pointe vers lui
(fonction membre publique de std::shared_ptr<T> )