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

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

optional, any and variant (C++17)

optional

any

variant

in_placein_place_typein_place_indexin_place_tin_place_type_tin_place_index_t

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

make_from_tuple (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Elementary string conversions

to_chars (C++17)

from_chars (C++17)

chars_format (C++17)

Type operations

declval (C++11)

as_const (C++17)

 

Dynamic memory management

Smart pointers unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (until C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) Allocators allocator allocator_traits (C++11) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Memory resources pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17)

Uninitialized storage uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) destroy_at (C++17) raw_storage_iterator (deprecated since c++17) get_temporary_buffer (deprecated since c++17) return_temporary_buffer (deprecated since c++17) Garbage collection support declare_reachable (C++11) undeclare_reachable (C++11) declare_no_pointers (C++11) undeclare_no_pointers (C++11) pointer_safety (C++11) get_pointer_safety (C++11) Miscellaneous pointer_traits (C++11) addressof (C++11) align (C++11) C Library malloc aligned_alloc (C++17) calloc realloc free Low level memory management

 

std::shared_ptr

Member functions

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modifiers

shared_ptr::reset

shared_ptr::swap

Observers

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::operator[] (C++17)

shared_ptr::use_count

shared_ptr::unique (deprecated)

shared_ptr::operator bool

shared_ptr::owner_before

Non-member functions

std::swap

make_shared

allocate_shared

static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)

get_deleter

operator==operator|=operator<operator<=operator>operator>=

operator<<

atomic_is_lock_freeatomic_loadatomic_load_explicitatomic_storeatomic_store_explicitatomic_exchangeatomic_exchange_explicitatomic_compare_exchange_weakatomic_compare_exchange_strongatomic_compare_exchange_weak_explicitatomic_compare_exchange_strong_explicit

std::hash

 

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

See also

get	returns the stored pointer (public member function)