std::cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal
De cppreference.com
| Definido en el archivo de 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 negativos con signo siempre se comparan menor que (y no igual que) los enteros con signo: la comparación es segura contra la conversión de enteros con pérdida.
-1 > 0u; // verdadero std::cmp_greater(-1, 0u); // falso
Es un error en tiempo de compilación si ya sea T o R no es un tipo entero con signo o sin signo (incluyendo el tipo entero estándar y los tipos enteros extendidos).
Contenido |
[editar] Parámetros
| t | - | Argumento del lado izquierdo. |
| u | - | Argumento del lado derecho. |
[editar] Valor de retorno
1) true si
t igual que u.2) true si
t no es igual que 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.[editar] Posible implementación
template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept { using UT = std::make_unsigned_t<T>; using UU = std::make_unsigned_t<U>; 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 ? false : UT(t) == u; else return u < 0 ? false : t == UU(u); } 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 { using UT = std::make_unsigned_t<T>; using UU = std::make_unsigned_t<U>; 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 ? true : UT(t) < u; else return u < 0 ? false : t < UU(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_greater(t, u); } template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept { return !cmp_less(t, u); } |
[editar] Notas
Estas funciones no pueden usarse para comparar std::byte, char, char8_t, char16_t, char32_t, wchar_t y bool.
[editar] Ejemplo
El ejemplo siguiente podría producir una advertencia comparación de signo distinto si se compila sin una bandera de supresión de advertencia apropiada, p. ej., -Wno-sign-compare (gcc/clang).
Ejecuta este código
#include <utility> int main() { static_assert( sizeof(int) == 4 ); // precondición // Muy sorprendente static_assert( -1 > 1U ); // ya que después de una 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 se espera: // los enteros con signo negativo siempre se comparan menores que los // los enteros sin signo: 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 ) ); }
