std::weak_order

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

template< class T, class U >
    requires /* see below */
constexpr std::weak_ordering weak_order(T&& t, U&& u) noexcept(/* see below */);

Compara dos valores mediante comparación a tres vías y produce un resultado de tipo std::weak_ordering.

Sean t y u expresiones y sean T y U que denotan decltype((t)) y decltype((u)) respectivamente, std::weak_order(t, u) es equivalente en 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 incluya una declaración de std::weak_order,
  • en caso contrario, si T es un tipo de punto flotante:
    • si std::numeric_limits<T>::is_iec559 es true, realiza la comparación de orden débil de valores de punto flotante (ver más abajo) y devuelve ese resultado como un valor de tipo std::weak_ordering,
    • en caso contrario, produce un valor de tipo std::weak_ordering que sea consistente con el orden observado por los operadores de comparación de T,
  • en caso contrario, std::weak_ordering(std::compare_three_way()(t, u)), si está bien formado,
  • en caso 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 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::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

Véase también