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)

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>=

Pairs and tuples

pair

tuple (C++11)

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)

declval (C++11)

 

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)
Uninitialized storage
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
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 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::use_count

shared_ptr::unique

shared_ptr::operator bool

shared_ptr::owner_before

Non-member functions

std::swap

make_shared

allocate_shared

static_pointer_castdynamic_pointer_castconst_pointer_cast

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 T* and U*

4) rhs < lhs

5) !(rhs < lhs)

6) !(lhs < rhs)

7) !lhs

8) !rhs

9) (bool)lhs

10) (bool)rhs

11) std::less<T*>()(lhs.get(), nullptr)

12) std::less<T*>()(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 a pointer to the managed object (public member function)