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)

 

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)

Swap, forward and move

swap

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 (deprecated)
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_cast dynamic_pointer_cast const_pointer_cast

get_deleter

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

operator<<

atomic_is_lock_free atomic_load atomic_load_explicit atomic_store atomic_store_explicit atomic_exchange atomic_exchange_explicit atomic_compare_exchange_weak atomic_compare_exchange_strong atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong_explicit

std::hash

 

template <class T, class U>     bool operator==(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(1)
template <class T, class U>     bool operator!=(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(2)
template <class T, class U>     bool operator<(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(3)
template <class T, class U>     bool operator>(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(4)
template <class T, class U>     bool operator<=(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(5)
template <class T, class U>     bool operator>=(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs);	(6)
template <class T>     bool operator==(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(7)
template <class T>     bool operator==(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(8)
template <class T>     bool operator!=(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(9)
template <class T>     bool operator!=(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(10)
template <class T>     bool operator<(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(11)
template <class T>     bool operator<(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(12)
template <class T>     bool operator<=(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(13)
template <class T>     bool operator<=(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(14)
template <class T>     bool operator>(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(15)
template <class T>     bool operator>(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(16)
template <class T>     bool operator>=(const shared_ptr<T>& lhs, std::nullptr_t rhs);	(17)
template <class T>     bool operator>=(std::nullptr_t lhs, const shared_ptr<T>& rhs);	(18)

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

  (since C++11)

See also

get	returns a pointer to the managed object (public member function)