What are some examples of using weak_ptr in C++11?

Can you explain what weak_ptr is in C++11?

Sure! In C++11, weak_ptr is a smart pointer that holds a non-owning reference to an object managed by shared_ptr. It helps prevent circular references.

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

Absolutely! 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> sharedPtr = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weakPtr = sharedPtr;

    if (auto tempPtr = weakPtr.lock()) {
        std::cout << "Weak pointer is valid" << std::endl;
    } else {
        std::cout << "Weak pointer is expired" << std::endl;
    }
    return 0;
}

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. You can check its validity using the lock() method, which returns a shared_ptr if the object is still alive.

Are there any performance considerations when using weak_ptr?

Yes, using weak_ptr can introduce some overhead due to the need to manage the reference count. However, it is generally lightweight compared to shared_ptr.