# std::shared_ptr::operator==, !=, <, <=, >, >=

From cppreference.com
< cpp‎ | memory‎ | shared ptr

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

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_ptr`s to be used as keys in associative containers, like std::map and std::set.

### Parameters

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

### Return value

1) `lhs.get() == rhs.get()`
2) !(lhs == rhs)
3) std::less<V>()(lhs.get(), rhs.get()), where V is the composite pointer type of std::shared_ptr<T>::element_type* and std::shared_ptr<U>::element_type*
4) rhs < lhs
5) !(rhs < lhs)
6) !(lhs < rhs)
7) !lhs
8) !rhs
9) (bool)lhs
10) (bool)rhs
11) std::less<std::shared_ptr<T>::element_type*>()(lhs.get(), nullptr)
12) std::less<std::shared_ptr<T>::element_type*>()(nullptr, rhs.get())
13) nullptr < lhs
14) rhs < nullptr
15) !(nullptr < lhs)
16) !(rhs < nullptr)
17) !(lhs < nullptr)
18) !(nullptr < rhs)

### Exceptions

`noexcept` specification:
noexcept

### 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.

### Example

| This section is incomplete Reason: no example

### See also

get | returns the stored pointer (public member function)

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/shared_ptr/operator_cmp&oldid=91578"
Categories:

- unconditionally noexcept
- Todo no example

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template