Espacios de nombres
Variantes

    std::compare_weak_order_fallback

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de servicios
    Apoyo del lenguaje
    Apoyo de tipos (tipos básicos, RTTI)
    Macros de prueba de característica de la biblioteca (C++20)
    Servicios de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Apoyo de corrutinas (C++20)
    Apoyo de contratos (C++26)
    Comparación de tres vías (C++20)
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)  
    (C++20)(C++20)(C++20)  
    (C++20)(C++20)(C++20)

     
    Definido en el archivo de encabezado <compare> 
    inline namespace /* no especificado */ {
    inline constexpr /* no especificado */
        compare_weak_order_fallback = /* no especificado */;
}
    		(desde C++20)
    Signatura de la llamada
    		 
    template< class T, class U >
    requires /* véase más abajo */
constexpr std::weak_ordering
    compare_weak_order_fallback(T&& t, U&& u) noexcept(/* véase más abajo */);

    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.

    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_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.

    Ejemplo

    Ejecuta este código
    #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
}

    Salida: 

    menor
mayor
mayor

    Véase también

    (C++20)
    		 Realiza una comparación de tres vías y produce un resultado de tipo std::weak_ordering.
    (objeto punto de personalización) [editar]