std::weak_ptr::~weak_ptr(3)

🫶 std::weak_ptr::~weak_ptr(3) — C++ Standard Libary manual 💖

okay bestie, gather round — this is the destructor page for std::weak_ptr, and it's from the C++ Standard Libary manual. It's short, it's sweet, and it's lowkey the “no drama” destructor. Let's get into it. ✨

💖 NAME 💖

std::weak_ptr::~weak_ptr — literally std::weak_ptr::~weak_ptr. That's the whole NAME line, bestie. Redundant? Maybe. Iconic? Absolutely. 👑

✨ Synopsis ✨

~weak_ptr();  (since C++11)

So this destructor has been around since C++11. It destroys the weak_ptr object. Results in no effect to the managed object — like, the managed object gets zero effect from this. None. Nada. 🫶

🎀 Example 🎀

The program shows the effect of "non-breaking" the cycle of std::shared_ptrs. (Yes, that's the exact phrase, and it's the whole point.) 🦋

// 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>). 💅

source/version: http://cppreference.com, 2024.06.10 · page: std::weak_ptr::~weak_ptr(3) — byeee, go destroy your weak_ptr responsibly 💖✨