How do I use weak_ptr in C++11?

Can you explain how to use weak_ptr in C++11?

Sure! In C++11, weak_ptr is used to break circular references between shared_ptr instances. It allows you to have a non-owning reference to an object managed by shared_ptr.

What is the main difference between shared_ptr and weak_ptr?

The main difference is that shared_ptr maintains ownership of the object, while weak_ptr does not. weak_ptr can be used to observe an object without preventing it from being deleted.

Can you give me an example of how to implement weak_ptr?

Certainly! Here's a simple example:

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> sp = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> wp = sp;

    if (auto spt = wp.lock()) { // Try to get a shared_ptr
        std::cout << "Weak pointer is valid" << std::endl;
    } else {
        std::cout << "Weak pointer is expired" << std::endl;
    }
}

This code demonstrates creating a weak_ptr from a shared_ptr.

What happens if the shared_ptr is deleted?

If the shared_ptr is deleted, the weak_ptr becomes expired, meaning it can no longer be used to access the object. You can check if it's expired using the expired() method.