Completely rewriting this answer because I totally misunderstood. This is a tricky thing to get right!
The usual implementation of
std::shared_ptr that is consistent with the standard is to have two heap objects: the managed object, and a control block. Each shared pointer that refers to the same object contains a pointer to the object and to the control block, and each weak pointer likewise. The control block keeps a record of the number of shared pointers and the number of weak pointers, and deallocates the managed object when the number of shared pointers reaches 0; the control block itself is deallocated when the number of weak pointers also reaches 0.
This is complicated by the fact that the object pointer in a shared or weak pointer can point to a subobject of the actual managed object, e.g. a base class, a member, or even another heap object that is owned by the managed object.
S0 ----------______ MO <------+ \__ `----> BC | \_ _______--------> m1 | ___X__ m2 --> H | S1 -/ \__ __----------------^ | \___ _____X__ | ____X________\__ | W0 /----------------`---> CB -------+ s = 2 w = 1
Here we have two shared pointers pointing respectively to a base class of the managed object and to a member, and a weak pointer pointing to a heap object owned by the managed object; the control block records that two shared pointers and one weak pointer exist. The control block also has a pointer to the managed object, which it uses to delete the managed object when it expires.
owner_less semantics are to compare shared and weak pointers by the address of their control block, which is guaranteed not to change unless the pointer itself is modified; even if a weak pointer expires because all shared pointers have been destructed, its control block still exists until all weak pointers have also been destructed.
equals code is absolutely correct and thread safe.
The issue is that it’s not consistent with
shared_ptr::operator== because that compares the object pointers, and two shared pointers with the same control block can point to different objects (as above).
For consistency with
t.lock() == u will be absolutely fine; note however that if it returns
true then it’s still not definite that the weak pointer is a weak pointer of the other shared pointer; it could be an alias pointer and so could still expire in following code.
However, comparing control blocks has less overhead (because it doesn’t need to look at the control block) and will give the same results as
== if you’re not using alias pointers.
I think that there’s something of a deficiency in the standard here; adding an
owner_hash would allow using
weak_ptr in unordered containers, and given
owner_equals it actually becomes sensible to compare weak pointers for equality, as you can safely compare the control block pointer then the object pointer, since if two weak pointers have the same control block then you know that either both or neither are expired. Something for the next version of the standard, perhaps.