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

  • A+
Category:Languages

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.

 


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.

Comment

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: