std::cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal, cmp_greater_equal – cppreference.com

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

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

Das Beispiele unten könnte Warnungen über different signedness comparison erzeugen, falls es nicht mit entsprechender Warnungsunterdrückung kompiliert wird, wie z.B. -Wno-sign-compare (gcc/clang mit -Wall -Wextra, siehe auch SO: disabling a specific warning).

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