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

Определено в заголовке `<utility>`
template< class T, class U > constexpr bool cmp_equal( T t, U u ) noexcept;	(1)	(с C++20)
template< class T, class U > constexpr bool cmp_not_equal( T t, U u ) noexcept;	(2)	(с C++20)
template< class T, class U > constexpr bool cmp_less( T t, U u ) noexcept;	(3)	(с C++20)
template< class T, class U > constexpr bool cmp_greater( T t, U u ) noexcept;	(4)	(с C++20)
template< class T, class U > constexpr bool cmp_less_equal( T t, U u ) noexcept;	(5)	(с C++20)
template< class T, class U > constexpr bool cmp_greater_equal( T t, U u ) noexcept;	(6)	(с C++20)

Сравнение значений двух целых чисел t и u. В отличие от встроенных операторов сравнения, отрицательные целые числа со знаком всегда сравниваются как меньше (и не равны) беззнаковым целым числам: сравнение защищено от преобразования целых чисел, не сохраняющего значение.

-1 > 0u; // true
std::cmp_greater(-1, 0u); // false

Если T или U является не целым типом, типом символа или bool, это ошибка времени компиляции.

Параметры

t	-	левое операнд
u	-	правое операнд

Возвращаемое значение

1) true если t равно u.

2) true если t не равно u.

3) true если t меньше u.

4) true если t больше u.

5) true если t меньше или равно u.

6) true если t больше или равно u.

Возможная реализация

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);
}

Примечания

Эти функции не могут использоваться для сравнения перечислений (включая std::byte), char, char8_t, char16_t, char32_t, wchar_t и bool.

Макрокоманда проверки наличия функции	Значение	Std	Функция
`__cpp_lib_integer_comparison_functions`	202002L	(C++20)	Функции сравнения целых чисел

Пример

В примере ниже может появиться предупреждение different signedness comparison, если компиляция выполняется без соответствующего флага подавления предупреждений, например, -Wno-sign-compare (gcc/clang с -Wall -Wextra, см. также SO: отключение конкретного предупреждения).

#include <utility>
 
// Uncommenting the next line will disable "signed/unsigned comparison" warnings:
// #pragma GCC diagnostic ignored "-Wsign-compare"
 
int main()
{
    static_assert(sizeof(int) == 4); // precondition
 
    // Quite surprisingly
    static_assert(-1 > 1U); //< warning: sign-unsign comparison
    // because after implicit conversion of -1 to the RHS type (`unsigned int`)
    // the expression is equivalent to:
    static_assert(0xFFFFFFFFU > 1U);
    static_assert(0xFFFFFFFFU == static_cast<unsigned>(-1));
 
    // In contrast, the cmp_* family compares integers as most expected -
    // negative signed integers always compare less than unsigned integers:
    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); //< warning: sign-unsign comparison
    static_assert(std::cmp_not_equal(-1, 0xFFFFFFFFU));
}

См. также

equal_to	объект функции, реализующий `x == y` (шаблон класса)
not_equal_to	объект функции, реализующий `x != y` (шаблон класса)
less	объект функции, реализующий `x < y` (шаблон класса)
greater	объект функции, реализующий `x > y` (шаблон класса)
less_equal	объект функции, реализующий `x <= y` (шаблон класса)
greater_equal	объект функции, реализующий `x >= y` (шаблон класса)
ranges::equal_to (C++20)	объект функции, реализующий `x == y` (класс)
ranges::not_equal_to (C++20)	объект функции, реализующий `x != y` (класс)
ranges::less (C++20)	объект функции, реализующий `x < y` (класс)
ranges::greater (C++20)	объект функции, реализующий `x > y` (класс)
ranges::less_equal (C++20)	объект функции, реализующий `x <= y` (класс)
ranges::greater_equal (C++20)	объект функции, реализующий `x >= y` (класс)
compare_three_way (C++20)	объект функции, реализующий `x <=> y` (класс)
in_range (C++20)	проверяет, находится ли целое значение в диапазоне заданного целого типа (шаблон функции)
numeric_limits	предоставляет интерфейс для запроса свойств всех основных числовых типов (шаблон класса)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/intcmp