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

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

-1 > 0u; // истина
std::cmp_greater(-1, 0u); // ложь

Это ошибка времени компиляции, если либо T , либо U является не- целочисленным типом, символьным типом или bool .

Параметры

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

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

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 .

Пример

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

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