std::weak_ptr::~weak_ptr(3)

NAME
std::weak_ptr::~weak_ptr - std::weak_ptr::~weak_ptr

Synopsis
   ~weak_ptr(); (since C++11)
   Destroys the weak_ptr object. Results in no effect to the managed object.

Example
   The program shows the effect of "non-breaking" the cycle of std::shared_ptrs. // Run this 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 << "' reclaimed\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); // produces a memory leak
 }

Output:
 One link is a weak_ptr
 Leaving...
   'A' reclaimed
   'B' reclaimed
   'C' reclaimed
 All links are shared pointers
 Leaving...

See also
   destructor destructs the owned object if no more shared_ptrs link to it
                (public member function of std::shared_ptr<T>)