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.

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

Пример

При компиляции приведённого ниже примера без соответствующего флага подавления предупреждений, например -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/cpp/utility/intcmp