std:: weak_order

Definido en el encabezado <compare>
inline namespace /* unspecified */ { inline constexpr /* unspecified */ weak_order = /* unspecified */ ; }		(desde C++20)
Firma de llamada
template < class T, class U > requires /* see below */ constexpr std:: weak_ordering weak_order ( T && t, U && u ) noexcept ( /* see below */ ) ;

Compara dos valores usando comparación de 3 vías y produce un resultado de tipo std::weak_ordering .

Sean t y u expresiones y T y U denoten decltype ( ( t ) ) y decltype ( ( u ) ) respectivamente, std :: weak_order ( t, u ) es equivalente-expresión a:

• Si std:: is_same_v < std:: decay_t < T > , std:: decay_t < U >> es true :
  • std:: weak_ordering ( weak_order ( t, u ) ) , si es una expresión bien formada con resolución de sobrecarga realizada en un contexto que no incluye una declaración de std::weak_order ,
  • de lo contrario, si T es un tipo de punto flotante:
    • si std:: numeric_limits < T > :: is_iec559 es true , realiza la comparación de ordenamiento débil de valores de punto flotante (ver abajo) y devuelve ese resultado como un valor de tipo std::weak_ordering ,
    • de lo contrario, produce un valor de tipo std::weak_ordering que es consistente con el ordenamiento observado por los operadores de comparación de T ,
  • de lo contrario, std:: weak_ordering ( std:: compare_three_way ( ) ( t, u ) ) , si está bien formado,
  • de lo contrario, std:: weak_ordering ( std:: strong_order ( t, u ) ) , si está bien formado.
• En todos los demás casos, la expresión está mal formada, lo que puede resultar en fallo de sustitución cuando aparece en el contexto inmediato de una instanciación de plantilla.

Contenidos 1 Objetos de punto de personalización 1.1 Orden débil estricto de tipos de punto flotante IEEE 2 Ejemplo 3 Véase también

Objetos de punto de personalización

El nombre std::weak_order denota un objeto de punto de personalización , que es un objeto función constante de un tipo de clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Orden estricto débil de los tipos de punto flotante IEEE

Sean x y y valores del mismo tipo de coma flotante IEEE, y weak_order_less ( x, y ) el resultado booleano que indica si x precede a y en el orden débil estricto definido por el estándar de C++.

• Si ni x ni y son NaN, entonces weak_order_less ( x, y ) == true si y solo si x < y , es decir, todas las representaciones de valores de punto flotante iguales son equivalentes;
• Si x es NaN negativo y y no es NaN negativo, entonces weak_order_less ( x, y ) == true ;
• Si x no es NaN positivo y y es NaN positivo, entonces weak_order_less ( x, y ) == true ;
• Si tanto x como y son NaNs con el mismo signo, entonces ( weak_order_less ( x, y ) || weak_order_less ( y, x ) ) == false , es decir, todos los NaNs con el mismo signo son equivalentes.

Ejemplo

Esta sección está incompleta Razón: sin ejemplo

Véase también

weak_ordering (C++20)	el tipo de resultado de comparación de 3 vías que admite los 6 operadores y no es sustituible (clase)
strong_order (C++20)	realiza una comparación de 3 vías y produce un resultado de tipo std::strong_ordering (objeto de punto de personalización)
partial_order (C++20)	realiza una comparación de 3 vías y produce un resultado de tipo std::partial_ordering (objeto de punto de personalización)
compare_weak_order_fallback (C++20)	realiza una comparación de 3 vías y produce un resultado de tipo std::weak_ordering , incluso si operator <=> no está disponible (objeto de punto de personalización)