std::shared_ptr::owner_before and std::owner_less: What exactly is meant by "owner-based order"?

Question

I have found a few discussions on this but nothing appears to ever specify what "owner based order" actually is.

Is it effectively evaluating < on the value of the owned pointer memory addresses?

Answer 1

It defines an arbitrary strict weak ordering under which two pointers are equivalent if and only if they share ownership or are both empty.

Equivalence is defined in the usual way:

bool equivalent(p1, p2) {
    return !p1.owner_before(p2) && !p2.owner_before(p1);
}

This doesn't necessarily mean that they point to the same object. Two pointers can point to different objects but still share ownership:

struct thing {int n;};
shared_ptr<thing> t1 = make_shared<thing>();
shared_ptr<int>   t2(t1, &t1->n);

assert(t1 != t2);          // point to different objects
assert(equivalent(t1,t2)); // share ownership

Likewise, two pointers can point to the same object without sharing:

thing t;
shared_ptr<thing> t1(&t, some_deleter());
shared_ptr<thing> t2(&t, some_deleter());

assert(t1 == t2);            // point to the same object
assert(!equivalent(t1, t2)); // don't share ownership

(Of course, this would be disastrous with the default deleter since both would try to delete the object; but there are sensible applications for this kind of thing with a suitable custom deleter).

In practice, this could be implemented by comparing the address of the internal structure used for the shared reference count.

Answer 2

Semantically, it means that two shared_ptrs compare equal if an only if they share ownership or are both nullptr, and otherwise there is some consistent ordering of shared_ptrs.

Effectively, this ordering is implemented by comparing the internal pointer to the reference control block that is shared between shared_ptrs that "share ownership." Note that it is possible to create shared_ptrs with differing get() that share ownership via the constructor:

template< class Y >
shared_ptr( const shared_ptr<Y>& r, T *ptr );

Which is useful, e.g, for handing out pointers to members of an object held by shared_ptr.