std::cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal
| 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) |
Compara los valores de dos enteros t y u. A diferencia de los operadores de comparación integrados, los enteros con signo negativos siempre se comparan menos que (y no igual a) los enteros sin signo: la comparación es segura contra conversiones de enteros que no preservan el valor.
-1 > 0u; // true
std::cmp_greater(-1, 0u); // false
Es un error en tiempo de compilación si T o U es un tipo no entero, un tipo carácter o bool.
Parámetros
| t | - | argumento izquierdo |
| u | - | argumento derecho |
Valor de retorno
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
).
#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) |