std::owner_less

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Memory management library

voidify

(exposition only*)

Allocators

allocator
allocator_traits (C++11)
allocation_result (C++23)
scoped_allocator_adaptor (C++11)
pmr::polymorphic_allocator (C++17)

allocator_arg (C++11)
uses_allocator (C++11)
uses_allocator_construction_args (C++20)
make_obj_using_allocator (C++20)
uninitialized_construct_using_allocator (C++20)

Uninitialized memory algorithms

uninitialized_copy
uninitialized_fill
uninitialized_move (C++17)
uninitialized_copy_n (C++11)
uninitialized_fill_n
uninitialized_move_n (C++17)
construct_at (C++20)

uninitialized_default_construct (C++17)
uninitialized_value_construct (C++17)
destroy (C++17)
uninitialized_default_construct_n (C++17)
uninitialized_value_construct_n (C++17)
destroy_n (C++17)
destroy_at (C++17)

Constrained uninitialized memory algorithms

ranges::uninitialized_copy (C++20)
ranges::uninitialized_fill (C++20)
ranges::uninitialized_move (C++20)
ranges::uninitialized_copy_n (C++20)
ranges::uninitialized_fill_n (C++20)
ranges::uninitialized_move_n (C++20)
ranges::construct_at (C++20)

ranges::uninitialized_default_construct (C++20)
ranges::uninitialized_value_construct (C++20)
ranges::destroy (C++20)
ranges::uninitialized_default_construct_n (C++20)
ranges::uninitialized_value_construct_n (C++20)
ranges::destroy_n (C++20)
ranges::destroy_at (C++20)

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::pool_options (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)

Explicit lifetime management
start_lifetime_as (C++23)
start_lifetime_as_array (C++23)

Types for composite class design
indirect (C++26)
polymorphic (C++26)

Uninitialized storage(until C++20)

raw_storage_iterator (until C++20*)
get_temporary_buffer (until C++20*)

return_temporary_buffer (until C++20*)

Garbage collector support(until C++23)

declare_reachable (C++11)(until C++23)
declare_no_pointers (C++11)(until C++23)
pointer_safety (C++11)(until C++23)

undeclare_reachable (C++11)(until C++23)
undeclare_no_pointers (C++11)(until C++23)
get_pointer_safety (C++11)(until C++23)

Low level memory
management

operator newoperator new[]

operator deleteoperator delete[]

(C++11)

(C++11)

(C++17)

(C++20)

(C++17)

(C++11)

(C++11)

(C++11)

(until C++17*)

owner_less

(C++11)

owner_less<void>

(C++17)

owner_hash

(C++26)

owner_equal

(C++26)

enable_shared_from_this

(C++11)

(C++11)

(C++11)

(C++23)

(C++23)

(C++11)

(C++20)

(C++11)

(C++11)

(C++20)

is_sufficiently_aligned

(C++26)

C Library

malloc
calloc
realloc

free
aligned_alloc (C++17)

[edit]

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 bothstd::weak_ptr andstd::shared_ptr. The order is such that two smart pointers compare equivalent only if they are both empty or if they share ownership, even if the values of the raw pointers obtained byget() are different (e.g. because they point at different subobjects within the same object).

1) Owner-based mixed-type ordering is not provided for types other thanstd::shared_ptr andstd::weak_ptr.

2) The owner-based mixed-type ordering ofstd::shared_ptr.

It is the preferred comparison predicate when building associative containers withstd::shared_ptr as keys, that is,std::map<std::shared_ptr<T>, U, std::owner_less<std::shared_ptr<T>>>.

3) The owner-based mixed-type ordering ofstd::weak_ptr.

It is the preferred comparison predicate when building associative containers withstd::weak_ptr as keys, that is,std::map<std::weak_ptr<T>, U, std::owner_less<std::weak_ptr<T>>>.

4) Thevoid specialization deduces the parameter types from the arguments.

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

Specializations

The standard library provides a specialization ofstd::owner_less whenT is not specified. In this case, the parameter types are deduced from the arguments (each of which must still be either astd::shared_ptr or astd::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)[edit]

(since C++17)

Nested types

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

(until C++20)

[edit]Member functions

operator()

compares its arguments using owner-based semantics
(function)

std::owner_less::operator()

member only of specialization(2)
bool operator()(conststd::shared_ptr<T>& lhs, conststd::shared_ptr<T>& rhs)constnoexcept;		(since C++11)
member only of specialization(3)
bool operator()(conststd::weak_ptr<T>& lhs, conststd::weak_ptr<T>& rhs)constnoexcept;		(since C++11)
member of both template specializations
bool operator()(conststd::shared_ptr<T>& lhs, conststd::weak_ptr<T>& rhs)constnoexcept;		(since C++11)
bool operator()(conststd::weak_ptr<T>& lhs, conststd::shared_ptr<T>& rhs)constnoexcept;		(since C++11)

Compareslhs andrhs using owner-based semantics. Effectively callslhs.owner_before(rhs).

The ordering is strict weak ordering relation.

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

Parameters

lhs, rhs

shared-ownership pointers to compare

Return value

true iflhs isless thanrhs as determined by the owner-based ordering,false otherwise.

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 2873	C++11	operator() was not required to be noexcept	required to be noexcept

[edit]See also

owner_before	provides owner-based ordering of shared pointers (public member function of`std::shared_ptr<T>`)[edit]
owner_before	provides owner-based ordering of weak pointers (public member function of`std::weak_ptr<T>`)[edit]