std::compare_partial_order_fallback

Realiza una comparación de tres vías en t y u y produce un resultado de tipo std::partial_ordering, incluso si el operador <=> no está disponible.

Dejemos que t y u sean expresiones y que T y U denoten a decltype((t)) y decltype((u)), respectivamente, std::compare_partial_order_fallback(t, u) es equivalente en expresión a:

• Si std::is_same_v<std::decay_t<T>, std::decay_t<U>> == true:
  • la expresión es equivalente en expresión a std::partial_order(t, u), si es una expresión bien formada;
  • de lo contrario, si tanto t == u como t < u están bien formadas y son convertibles a bool, la expresión es equivalente en expresión a:

t == u ? std::partial_ordering::equivalent :
t < u  ? std::partial_ordering::less :
u < t  ? std::partial_ordering::greater :
         std::partial_ordering::unordered

excepto que t y u se evalúan solamente una vez.

• En todos los otros casos, std::compare_partial_order_fallback(t, u) está mal formada.

Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

Objetos de punto de personalización

El nombre std::compare_partial_order_fallback denota un objeto de punto de personalización, que es un objeto función const de un tipo clase literal semiregular (denotado, a efectos de exposición, como compare_partial_order_fallback_ftor). Todos los ejemplares de compare_partial_order_fallback_ftor son iguales. Por lo tanto, std::compare_partial_order_fallback puede copiarse libremente y sus copias pueden usarse indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de std::compare_partial_order_fallback mencionado anteriormente, compare_partial_order_fallback_ftor satisfará a std::invocable<const compare_partial_order_fallback_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de compare_partial_order_fallback_ftor participa en la resolución de sobrecarga.

Ejemplo

Véase también