std::strong_order

inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ strong_order = /* unspecified */;
}

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 una comparación de 3 vías y produce un resultado de tipo std::strong_ordering.

Sean t y u expresiones y sean T y U que denotan decltype((t)) y decltype((u)) respectivamente, std::strong_order(t, u) es equivalente a la expresión:

• 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 ISO/IEC/IEEE 60559 totalOrder 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 ordenamiento 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 un fallo de sustitución cuando aparece en el contexto inmediato de una instanciación de plantilla.

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

Véase también