Namespaces
Variants

std:: cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal

From cppreference.net
C++
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
cmp_equal cmp_less cmp_less_than
(C++20) (C++20) (C++20)
cmp_not_equal cmp_greater cmp_greater_than
(C++20) (C++20) (C++20)
(C++20)
Swap and type operations
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)


Definido en el encabezado <utility>
template < class T, class U >
constexpr bool cmp_equal ( T t, U u ) noexcept ;
(1) (desde C++20)
template < class T, class U >
constexpr bool cmp_not_equal ( T t, U u ) noexcept ;
(2) (desde C++20)
template < class T, class U >
constexpr bool cmp_less ( T t, U u ) noexcept ;
(3) (desde C++20)
template < class T, class U >
constexpr bool cmp_greater ( T t, U u ) noexcept ;
(4) (desde C++20)
template < class T, class U >
constexpr bool cmp_less_equal ( T t, U u ) noexcept ;
(5) (desde C++20)
template < class T, class U >
constexpr bool cmp_greater_equal ( T t, U u ) noexcept ;
(6) (desde C++20)

Compare los valores de dos enteros t y u . A diferencia de los operadores de comparación incorporados, los enteros con signo negativos siempre comparan menor que (y no igual a ) los enteros sin signo: la comparación es segura contra la conversión de enteros que no preserva valores. 

-1 > 0u; // verdadero
std::cmp_greater(-1, 0u); // falso

Es un error en tiempo de compilación si ya sea T o U es un tipo no- entero , un tipo de carácter, o bool .

Contenidos

Parámetros

t - argumento izquierdo
u - argumento derecho

Valor de retorno

1) true si t es igual a u .
2) true si t no es igual a u .
3) true si t es menor que u .
4) true si t es mayor que u .
5) true si t es menor o igual que u .
6) true si t es mayor o igual que u .

Implementación posible 

template<class T, class U>
constexpr bool cmp_equal(T t, U u) noexcept
{
    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
        return t == u;
    else if constexpr (std::is_signed_v<T>)
        return t >= 0 && std::make_unsigned_t<T>(t) == u;
    else
        return u >= 0 && std::make_unsigned_t<U>(u) == t;
}
template<class T, class U>
constexpr bool cmp_not_equal(T t, U u) noexcept
{
    return !cmp_equal(t, u);
}
template<class T, class U>
constexpr bool cmp_less(T t, U u) noexcept
{
    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
        return t < u;
    else if constexpr (std::is_signed_v<T>)
        return t < 0 || std::make_unsigned_t<T>(t) < u;
    else
        return u >= 0 && t < std::make_unsigned_t<U>(u);
}
template<class T, class U>
constexpr bool cmp_greater(T t, U u) noexcept
{
    return cmp_less(u, t);
}
template<class T, class U>
constexpr bool cmp_less_equal(T t, U u) noexcept
{
    return !cmp_less(u, t);
}
template<class T, class U>
constexpr bool cmp_greater_equal(T t, U u) noexcept
{
    return !cmp_less(t, u);
}

Notas

Estas funciones no pueden utilizarse para comparar enums (incluyendo std::byte ), char , char8_t , char16_t , char32_t , wchar_t y bool .

Macro de prueba de características Valor Std Característica
__cpp_lib_integer_comparison_functions 202002L (C++20) Funciones de comparación de enteros

Ejemplo

El ejemplo a continuación podría producir una advertencia de comparación de signo diferente si se compila sin un indicador de supresión de advertencias apropiado, por ejemplo, -Wno-sign-compare (gcc/clang con -Wall -Wextra , ver también SO: deshabilitar una advertencia específica ).

Ejecutar este código 
#include <utility>
// Descomentar la siguiente línea deshabilitará las advertencias de "comparación signada/no signada":
// #pragma GCC diagnostic ignored "-Wsign-compare"
int main()
{
    static_assert(sizeof(int) == 4); // precondición
    // Sorprendentemente
    static_assert(-1 > 1U); //< advertencia: comparación signo-no signo
    // porque después de la conversión implícita de -1 al tipo del lado derecho (`unsigned int`)
    // la expresión es equivalente a:
    static_assert(0xFFFFFFFFU > 1U);
    static_assert(0xFFFFFFFFU == static_cast<unsigned>(-1));
    // En contraste, la familia cmp_* compara enteros como la mayoría esperaría -
    // los enteros signados negativos siempre se comparan menores que los enteros no signados:
    static_assert(std::cmp_less(-1, 1U));
    static_assert(std::cmp_less_equal(-1, 1U));
    static_assert(!std::cmp_greater(-1, 1U));
    static_assert(!std::cmp_greater_equal(-1, 1U));
    static_assert(-1 == 0xFFFFFFFFU); //< advertencia: comparación signo-no signo
    static_assert(std::cmp_not_equal(-1, 0xFFFFFFFFU));
}

Véase también

objeto función que implementa x == y
(plantilla de clase)
objeto función que implementa x ! = y
(plantilla de clase)
objeto función que implementa x < y
(plantilla de clase)
objeto función que implementa x > y
(plantilla de clase)
objeto función que implementa x <= y
(plantilla de clase)
objeto función que implementa x >= y
(plantilla de clase)
(C++20)
objeto función restringido que implementa x == y
(clase)
(C++20)
objeto función restringido que implementa x ! = y
(clase)
(C++20)
objeto función restringido que implementa x < y
(clase)
(C++20)
objeto función restringido que implementa x > y
(clase)
(C++20)
objeto función restringido que implementa x <= y
(clase)
(C++20)
objeto función restringido que implementa x >= y
(clase)
(C++20)
objeto función restringido que implementa x <=> y
(clase)
(C++20)
verifica si un valor entero está en el rango de un tipo entero dado
(plantilla de función)
proporciona una interfaz para consultar propiedades de todos los tipos numéricos fundamentales
(plantilla de clase)