std::cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal
De cppreference.com
<tbody>
</tbody>
| 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).
Parámetros
| t | - | Argumento del lado izquierdo. |
| u | - | Argumento del lado derecho. |
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.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);
}
|
Notas
Estas funciones no pueden usarse para comparar std::byte, char, char8_t, char16_t, char32_t, wchar_t y bool.
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 ) );
}