# std::weak_ptr<T>::~weak_ptr

From cppreference.com
< cpp‎ | memory‎ | weak ptr

~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_ptr`s link to it (public member function of `std::shared_ptr<T>`)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/weak_ptr/%7Eweak_ptr&oldid=153996"