std::owner_less

 

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 and any

optional (C++17)

any (C++17)

Pairs and tuples

pair

tuple (C++11)

apply (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)

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

 

Defined in header <memory>
	(1)
template< class T > struct owner_less; /* undefined */			(since C++11) (until C++17)
template< class T = void > struct owner_less; /* undefined */			(since C++17)
template< class T > struct owner_less<std::shared_ptr<T>>;		(2)	(since C++11)
template< class T > struct owner_less<std::weak_ptr<T>>;		(3)	(since C++11)
template<> struct owner_less<void>;		(4)	(since C++17)

This function object provides owner-based (as opposed to value-based) mixed-type ordering of both std::weak_ptr and std::shared_ptr. The order is such that two smart pointers compare equivalent only if they are both empty or if they both manage the same object, even if the values of the raw pointers obtained by get() are different (e.g. because they point at different subobjects within the same object)

This class template is the preferred comparison predicate when building associative containers with std::shared_ptr or std::weak_ptr as keys, that is,

std::map<std::shared_ptr<T>, U, std::owner_less<std::shared_ptr<T>>>

or

std::map<std::weak_ptr<T>, U, std::owner_less<std::weak_ptr<T>>>.

The default operator< is not defined for weak pointers, and may wrongly consider two shared pointers for the same object non-equivalent (see shared_ptr::owner_before)

Specializations

The standard library provides a specialization of std::owner_less when T is not specified. In this case, the parameter types are deduced from the arguments (each of which must still be either a std::shared_ptr or a std::weak_ptr). owner_less<void> function object providing mixed-type owner-based ordering of shared and weak pointers, regardless of the type of the pointee (class template specialization)

(since C++17)

Member types

Member type	Definition
result_type(deprecated in c++17)	2-3) bool
first_argument_type(deprecated in c++17)	2) std::shared_ptr<T> 3) std::weak_ptr<T>
second_argument_type(deprecated in c++17)	2) std::shared_ptr<T> 3) std::weak_ptr<T>

Member functions

operator()

compares its arguments using owner-based semantics (function)

std::owner_less::operator()

bool operator()( const std::shared_ptr<T>& lhs,                  const std::shared_ptr<T>& rhs ) const;		(since C++11) (member only of owner_less<shared_ptr<T>> template specialization)
bool operator()( const std::shared_ptr<T>& lhs,                  const std::weak_ptr<T>& rhs ) const;		(since C++11)
bool operator()( const std::weak_ptr<T>& lhs,                  const std::shared_ptr<T>& rhs ) const;		(since C++11)
bool operator()( const std::weak_ptr<T>& lhs,                  const std::weak_ptr<T>& rhs ) const;		(since C++11) (member only of owner_less<weak_ptr<T>> template specialization)

Compares lhs and rhs using owner-based semantics. Effectively calls lhs.owner_before(rhs).

The ordering is strict weak ordering relation.

lhs and rhs are equivalent only if they are both empty or share ownership.

Parameters

lhs, rhs

-

shared-ownership pointers to compare

Return value

true if lhs is less than rhs as determined by the owner-based ordering.

Exceptions

(none)

See also

owner_before	provides owner-based ordering of shared pointers (public member function of std::shared_ptr)
owner_before	provides owner-based ordering of weak pointers (public member function of std::weak_ptr)