shared_ptr operator < compares managed pointers instead of stored pointers

[JoergRuedenauer]

operator < of boost::shared_ptr compares the managed pointers:

template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
{
    return a.owner_before( b );
}
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
{
    return pn < rhs.pn;
}

This is also documented as

under the equivalence relation defined by operator<, !(a < b) && !(b < a), two shared_ptr instances are equivalent if and only if they share ownership or are both empty.

However, std::shared_ptr compares the stored pointers. Comparing the managed pointers defeats the purpose of the aliasing constructor and is asymmetrical to operator==, which does compare the stored pointers. See https://en.cppreference.com/w/cpp/memory/shared_ptr/operator_cmp:

In all cases, it is the stored pointer (the one returned by get()) that is compared, rather than the managed pointer (the one passed to the deleter when use_count goes to zero). The two pointers may differ in a shared_ptr created using the aliasing constructor.

See a minimal repro here: https://godbolt.org/z/xon8cxnss

[pdimov]

The current semantics of operator< are intentional. They predate std::shared_ptr. The committee changed operator< for shared_ptr to compare the pointer values, but that was after shared_ptr was added to the standard.

(std::shared_ptr also defines the rest of the comparison operators, and we do not.)

[Lev275568]

case is broken for std::set:

 class MyClass : public boost::enable_shared_from_this<MyClass>
 { };

 std::set<boost::local_shared_ptr<MyClass>> set;
 auto shared = boost::make_shared<MyClass>();
 set.emplace(shared);
 boost::local_shared_ptr<MyClass> localShared{shared->shared_from_this()};
 //assert(set.erase(localShared) == 1); // case 1. fails
 //assert(set.erase(*std::ranges::find(set, localShared)) == 1); // case 2. ok