Namespaces
Variants

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

    Начиная с ru.cppreference.net
     
    C++
    Поддержка компиляторов
    Автономные и с поддержкой среды
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы тестирования возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концепций (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Библиотека численных операций
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки параллелизма (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Индекс символов
    Внешние библиотеки
     
    Библиотека утилит
    Поддержка языка
    Поддержка типов (основные типы, RTTI)
    Макросы тестирования возможностей библиотеки (C++20)
    Утилиты программ
    Функции с переменным числом аргументов
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Поддержка корутин (C++20)
    Поддержка контрактов (C++26)
    Трёхстороннее сравнение
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Общие утилиты
    Операторы отношений (устарело в C++20)
    Функции сравнения целых чисел
    (C++20)(C++20)(C++20)    
    (C++20)
    Обмен и операции с типами
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Общеупотребительные типы-словари
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Определено в заголовке <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);
}

    Примечания

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

    Макрос тестирования возможностей Значение Стандарт Функция
    __cpp_lib_integer_comparison_functions 202002L (C++20) Функции сравнения целых чисел

    Пример

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

    Запустить этот код 
    #include <utility>
// Раскомментирование следующей строки отключит предупреждения "signed/unsigned comparison":
// #pragma GCC diagnostic ignored "-Wsign-compare"
int main()
{
    static_assert(sizeof(int) == 4); // предусловие
    // Достаточно неожиданно
    static_assert(-1 > 1U); //< warning: sign-unsign comparison
    // поскольку после неявного преобразования -1 к типу правой части (`unsigned int`)
    // выражение эквивалентно:
    static_assert(0xFFFFFFFFU > 1U);
    static_assert(0xFFFFFFFFU == static_cast<unsigned>(-1));
    // В отличие от этого, семейство функций cmp_* сравнивает целые числа как и ожидается -
    // отрицательные знаковые числа всегда сравниваются меньше беззнаковых:
    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));
}

    Смотрите также

    		функциональный объект, реализующий x == y
    (шаблон класса)
    		функциональный объект, реализующий x ! = y
    (шаблон класса)
    		функциональный объект, реализующий x < y
    (шаблон класса)
    		функциональный объект, реализующий x > y
    (шаблон класса)
    		функциональный объект, реализующий x <= y
    (шаблон класса)
    		функциональный объект, реализующий x >= y
    (шаблон класса)
    (C++20)
    		ограниченный функциональный объект, реализующий x == y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x ! = y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x < y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x > y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x <= y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x >= y
    (класс)
    (C++20)
    		ограниченный функциональный объект, реализующий x <=> y
    (класс)
    (C++20)
    		проверяет, находится ли целочисленное значение в диапазоне заданного целочисленного типа
    (шаблон функции)
    		предоставляет интерфейс для запроса свойств всех фундаментальных числовых типов
    (шаблон класса)