std::compare_weak_order_fallback

Realiza una comparación de tres vías en t y u y produce un resultado de tipo std::weak_ordering, even 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_weak_order_fallback(t, u) ies 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::weak_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::weak_ordering::equivalent :
t < u  ? std::weak_ordering::less :
         std::weak_ordering::greater

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

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

[editar] 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.

[editar] Objetos de punto de personalización

El nombre std::compare_weak_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_weak_order_fallback_ftor). Todos los ejemplares de compare_weak_order_fallback_ftor son iguales. Por lo tanto, std::compare_weak_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_weak_order_fallback mencionado anteriormente, compare_weak_order_fallback_ftor satisfará a std::invocable<const compare_weak_order_fallback_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de compare_weak_order_fallback_ftor participa en la resolución de sobrecarga.

[editar] Ejemplo

#include <iostream>
#include <compare>
 
// no soporta <=>
struct Rational_1 {
    int num;
    int den; // > 0
};
 
inline constexpr bool operator<(Rational_1 lhs, Rational_1 rhs)
{
    return lhs.num * rhs.den < rhs.num * lhs.den;
}
 
inline constexpr bool operator==(Rational_1 lhs, Rational_1 rhs)
{
    return lhs.num * rhs.den == rhs.num * lhs.den;
}
 
// soporta <=>
struct Rational_2 {
    int num;
    int den; // > 0
};
 
inline constexpr std::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs)
{
    return lhs.num * rhs.den <=> rhs.num * lhs.den;
}
 
void print(std::weak_ordering value)
{
    if (value == 0)
        std::cout << "igual\n";
    else if (value < 0)
        std::cout << "menor\n";
    else
        std::cout << "mayor\n";
}
 
int main()
{
    Rational_1 a{1, 2};
    Rational_1 b{3, 4};
//  print(a <=> b);                // no funciona
    print(std::compare_weak_order_fallback(a, b)); // funciona, se predetermina a < y ==
 
    Rational_2 c{6, 5};
    Rational_2 d{8, 7};
    print(c <=> d);                // funciona
    print(std::compare_weak_order_fallback(c, d)); // funciona
}

menor
mayor
mayor

[editar] Véase también