Once a lock on std::weak_ptr has returned nullptr, can it ever be non-null again?

Question

If you take a lock on std::weak_ptr:

    class foo {};

    auto s = std::make_shared<foo>();

    std::weak_ptr<foo> w{ s };

    s = nullptr;

    s.reset(new foo());

    auto l = w.lock(); // try to get previous foo

    std::cout << "locked: " << (l != nullptr) << std::endl;

Output:

locked: 0

Once lock returns nullptr, is there ever a condition under which it could return non-null, or is it effectively dead?

My test program suggests once the originally allocated object's reference count is zero then no, weak_ptr will always return a nullptr.

Answer 1

is there every a condition under which it could return non-null, or is it effectively dead?

Well, it's "almost" dead at that point. lock calls expired in a way equivalent to this:

expired() ? shared_ptr<T>() : shared_ptr<T>(*this)

Then, looking at the expiration condition:

Equivalent to use_count() == 0. The destructor for the managed object may not yet have been called, but this object's destruction is imminent (or may have already happened).

Either way, there's no possibility for that specific weak_ptr to be reassigned to another value.

Answer 2

#include <iostream>
#include <memory>

int
main()
{
    using namespace std;
    shared_ptr<int> p(new int{3});
    weak_ptr<int> w = p;
    p = nullptr;
    auto l = w.lock();
    if (l == nullptr)
        cout << "l = nullptr\n";
    else
        cout << "l = " << *l << '\n';
    p.reset(new int{4});
    w = p;
    l = w.lock();
    if (l == nullptr)
        cout << "l = nullptr\n";
    else
        cout << "l = " << *l << '\n';
}

Portable output:

l = nullptr
l = 4

So yes, if the weak_ptr is assigned from a non-empty shared_ptr, it can become "reanimated from the dead."

Maybe that isn't what you meant. But it is what you asked.