operator==, !=, <, <=, >, >=, <=> (std::shared_ptr) (original) (raw)

Defined in header
Compare two shared_ptr objects.
template< class T, class U > bool operator==( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (1) (since C++11)
template< class T, class U > bool operator!=( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (2) (since C++11) (until C++20)
template< class T, class U > bool operator<( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (3) (since C++11) (until C++20)
template< class T, class U > bool operator>( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (4) (since C++11) (until C++20)
template< class T, class U > bool operator<=( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (5) (since C++11) (until C++20)
template< class T, class U > bool operator>=( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (6) (since C++11) (until C++20)
template< class T, class U > std::strong_ordering operator<=>( const std::shared_ptr<T>& lhs, const std::shared_ptr<U>& rhs ) noexcept; (7) (since C++20)
Compare a shared_ptr with a null pointer.
template< class T > bool operator==( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (8) (since C++11)
template< class T > bool operator==( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (9) (since C++11) (until C++20)
template< class T > bool operator!=( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (10) (since C++11) (until C++20)
template< class T > bool operator!=( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (11) (since C++11) (until C++20)
template< class T > bool operator<( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (12) (since C++11) (until C++20)
template< class T > bool operator<( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (13) (since C++11) (until C++20)
template< class T > bool operator>( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (14) (since C++11) (until C++20)
template< class T > bool operator>( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (15) (since C++11) (until C++20)
template< class T > bool operator<=( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (16) (since C++11) (until C++20)
template< class T > bool operator<=( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (17) (since C++11) (until C++20)
template< class T > bool operator>=( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (18) (since C++11) (until C++20)
template< class T > bool operator>=( std::nullptr_t, const std::shared_ptr<T>& rhs ) noexcept; (19) (since C++11) (until C++20)
template< class T > std::strong_ordering operator<=>( const std::shared_ptr<T>& lhs, std::nullptr_t ) noexcept; (20) (since C++20)

Compares two shared_ptr<T> objects or compares shared_ptr<T> with a null pointer.

Note that the comparison operators for shared_ptr simply compare pointer values; the actual objects pointed to are not compared. Having operator< defined for shared_ptr allows shared_ptrs to be used as keys in associative containers, like std::map and std::set.

The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively. (since C++20)

[edit] Parameters

lhs - the left-hand shared_ptr to compare
rhs - the right-hand shared_ptr to compare

[edit] Return value

  1. lhs.get() == rhs.get()

  2. !(lhs == rhs)

  3. rhs < lhs

  4. !(rhs < lhs)

  5. !(lhs < rhs)

  6. !lhs

  7. !rhs

  8. (bool)lhs

  9. (bool)rhs

  10. nullptr < lhs

  11. rhs < nullptr

  12. !(nullptr < lhs)

  13. !(rhs < nullptr)

  14. !(lhs < nullptr)

  15. !(nullptr < rhs)

[edit] Notes

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.

[edit] Example

#include #include   int main() { std::shared_ptr p1(new int(42)); std::shared_ptr p2(new int(42));   std::cout << std::boolalpha << "(p1 == p1)  : " << (p1 == p1) << '\n' << "(p1 <=> p1) == 0 : " << ((p1 <=> p1) == 0) << '\n' // Since C++20   // p1 and p2 point to different memory locations, so p1 != p2 << "(p1 == p2)  : " << (p1 == p2) << '\n' << "(p1 < p2)  : " << (p1 < p2) << '\n' << "(p1 <=> p2) < 0  : " << ((p1 <=> p2) < 0) << '\n' // Since C++20 << "(p1 <=> p2) == 0 : " << ((p1 <=> p2) == 0) << '\n'; // Since C++20 }

Possible output:

(p1 == p1)  : true (p1 <=> p1) == 0 : true (p1 == p2)  : false (p1 < p2)  : true (p1 <=> p2) < 0  : true (p1 <=> p2) == 0 : false

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 3427 C++20 operator<=>(shared_ptr, nullptr_t) was ill-formed definition fixed

[edit] See also

| | returns the stored pointer (public member function) [edit] | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |