std::owner_less

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Gestión de memoria dinámica

Punteros inteligentes unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (hasta C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) Asignadores de memoria allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg_t (C++11) 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) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Recursos de memoria 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) Almacenamiento no inicializado raw_storage_iterator (hasta C++20) get_temporary_buffer (hasta C++20) return_temporary_buffer (hasta C++20)

Algoritmos de memoria no inicializada uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (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) construct_at (C++20) Algoritmos restringidos de memoria no inicializada ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Apoyo para recolección de basura declare_reachable (C++11)(hasta C++23) undeclare_reachable (C++11)(hasta C++23) declare_no_pointers (C++11)(hasta C++23) undeclare_no_pointers (C++11)(hasta C++23) pointer_safety (C++11)(hasta C++23) get_pointer_safety (C++11)(hasta C++23) Misceláneos pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Biblioteca de C malloc aligned_alloc (C++17) calloc realloc free Gestión de memoria de bajo nivel operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

Definido en el archivo de encabezado <memory>
	(1)
template< class T > struct owner_less; /* no definido */			(desde C++11) (hasta C++17)
template< class T = void > struct owner_less; /* no definido */			(desde C++17)
template< class T > struct owner_less<std::shared_ptr<T>>;		(2)	(desde C++11)
template< class T > struct owner_less<std::weak_ptr<T>>;		(3)	(desde C++11)
template<> struct owner_less<void>;		(4)	(desde C++17)

See More

Este objeto función proporciona una ordenación de tipo mixto basada en propietario (a diferencia de la basada el valor) de std::weak_ptr y std::shared_ptr. El orden es tal que dos punteros inteligentes se comparan equivalentes solo si ambos están vacíos o si comparten la posesión, incluso si los valores de los punteros sin formato obtenidos por get() son diferentes (por ejemplo, porque apuntan a diferentes subobjetos dentro del mismo objeto). Esta plantilla de clase es el predicado de comparación preferido cuando se crean contenedores asociativos con std::shared_ptr o std::weak_ptr como claves, es decir,

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

o

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

El operator< por defecto no está definido para punteros débiles y puede considerar erróneamente que dos punteros compartidos para el mismo objeto no son equivalentes (véase shared_ptr::owner_before).

Especializaciones

La biblioteca estándar proporciona una especialización de std::owner_less cuando no se especifica T. En este caso, los tipos de parámetros se deducen de los argumentos (cada uno de los cuales debe ser std::shared_ptr o std::weak_ptr). owner_less<void> Objeto función que proporciona un orden basado en propietario, de tipo mixto, de punteros compartidos y débiles, independientemente del tipo de objeto al que se apunta. (especialización de plantilla de clase)

(desde C++17)

Tipos miembro Tipos miembro Definición result_type(en desuso en c++17) 2-3) bool first_argument_type(en desuso en c++17) 2) std::shared_ptr<T> 3) std::weak_ptr<T> second_argument_type(en desuso en c++17) 2) std::shared_ptr<T> 3) std::weak_ptr<T>

(hasta C++20)

Funciones miembro

operator()

Compara sus argumentos con semántica basada en propietario. (función)

std::owner_less::operator()

<tbody> </tbody>

Miembro solo de la especialización de plantilla owner_less<shared_ptr<T>>
bool operator()( const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs ) const noexcept;		(desde C++11)
Miembro solo de la especialización de plantilla owner_less<weak_ptr<T>>
bool operator()( const std::weak_ptr<T>& lhs, const std::weak_ptr<T>& rhs ) const noexcept;		(desde C++11)
Miembro de ambas especializaciones de plantilla
bool operator()( const std::shared_ptr<T>& lhs, const std::weak_ptr<T>& rhs ) const noexcept;		(desde C++11)
bool operator()( const std::weak_ptr<T>& lhs, const std::shared_ptr<T>& rhs ) const noexcept;		(desde C++11)

Compara lhs y rhs usando semántica basada en propietario. Efectivamente llama a lhs.owner_before(rhs).

El ordenamiento es una estricta relación de ordenamiento débil.

lhs y rhs son equivalentes solo si ambos están vacíos o comparten la posesión.

Parámetros

lhs, rhs

-

Punteros de posesión compartida a comparar.

Valor de retorno

true si lhs es menor que rhs como se determine por el ordenamiento basado en propietario.

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2873	C++11	Los operadores operator() podrían no estar declarados noexcept.	Se declaran noexcept.

Véase también

owner_before	Proporciona un ordenamiento de punteros compartidos basado en propietario. (función miembro pública de std::shared_ptr<T>)
owner_before	Proporciona ordenamiento de punteros débiles basado en propietario. (función miembro pública de std::weak_ptr)