std:: strong_order

Definido en el encabezado <compare>
inline namespace /* unspecified */ { inline constexpr /* unspecified */ strong_order = /* unspecified */ ; }		(desde C++20)
Firma de llamada
template < class T, class U > requires /* see below */ constexpr std:: strong_ordering strong_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::strong_ordering .

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

• Si std:: is_same_v < std:: decay_t < T > , std:: decay_t < U >> es true :
  • std:: strong_ordering ( strong_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::strong_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 orden total ISO/IEC/IEEE 60559 de valores de punto flotante y devuelve ese resultado como un valor de tipo std::strong_ordering (nota: esta comparación puede distinguir entre el cero positivo y negativo y entre los NaN con diferentes representaciones),
    • de lo contrario, produce un valor de tipo std::strong_ordering que es consistente con el orden observado por los operadores de comparación de T ,
  • de lo contrario, std:: strong_ordering ( std:: compare_three_way ( ) ( t, u ) ) si está bien formada.
• 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 total estricto de tipos de punto flotante IEEE 2 Ejemplo 3 Véase también

Objetos de punto de personalización

El nombre std::strong_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 total estricto de tipos de punto flotante IEEE

Sean x e y valores del mismo tipo de coma flotante IEEE, y total_order_less ( x, y ) el resultado booleano que indica si x precede a y en el orden total estricto definido por totalOrder en ISO/IEC/IEEE 60559.

( total_order_less ( x, y ) || total_order_less ( y, x ) ) == false si y solo si x y y tienen el mismo patrón de bits.

• si ninguno x ni y es NaN:
  • si x < y , entonces total_order_less ( x, y ) == true ;
  • si x > y , entonces total_order_less ( x, y ) == false ;
  • si x == y ,
    • si x es cero negativo y y es cero positivo, total_order_less ( x, y ) == true ,
    • si x no es cero y el campo de exponente de x es menor que el de y , entonces total_order_less ( x, y ) == ( x > 0 ) (solo significativo para números de punto flotante decimal);
• si alguno x o y es NaN:
  • si x es NaN negativo y y no es NaN negativo, entonces total_order_less ( x, y ) == true ,
  • si x no es NaN positivo y y es NaN positivo, entonces total_order_less ( x, y ) == true ,
  • si ambos x y y son NaNs con el mismo signo y el campo de mantisa de x es menor que el de y , entonces total_order_less ( x, y ) == ! std:: signbit ( x ) .

Ejemplo

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

Véase también

strong_ordering (C++20)	el tipo de resultado de comparación de 3 vías que admite los 6 operadores y es sustituible (clase)
weak_order (C++20)	realiza una comparación de 3 vías y produce un resultado de tipo std::weak_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_strong_order_fallback (C++20)	realiza una comparación de 3 vías y produce un resultado de tipo std::strong_ordering , incluso si operator <=> no está disponible (objeto de punto de personalización)