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

From cppreference.com
C++
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
cmp_equal cmp_less cmp_less_than
(C++20) (C++20) (C++20)
cmp_not_equal cmp_greater cmp_greater_than
(C++20) (C++20) (C++20)
(C++20)
Swap and type operations
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
Elementary string conversions

Defined in header <utility>
template < class T, class U >
constexpr bool cmp_equal ( T t, U u ) noexcept ;
(1) (since C++20)
template < class T, class U >
constexpr bool cmp_not_equal ( T t, U u ) noexcept ;
(2) (since C++20)
template < class T, class U >
constexpr bool cmp_less ( T t, U u ) noexcept ;
(3) (since C++20)
template < class T, class U >
constexpr bool cmp_greater ( T t, U u ) noexcept ;
(4) (since C++20)
template < class T, class U >
constexpr bool cmp_less_equal ( T t, U u ) noexcept ;
(5) (since C++20)
template < class T, class U >
constexpr bool cmp_greater_equal ( T t, U u ) noexcept ;
(6) (since C++20)

Compare the values of two integers t and u . Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to ) unsigned integers: the comparison is safe against non-value-preserving integer conversion. 

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

It is a compile-time error if either T or U is a non- integer type, a character type, or bool .

Parameters

t - left-hand argument
u - right-hand argument

Return value

1) true if t is equal to u .
2) true if t is not equal to u .
3) true if t is less than u .
4) true if t is greater than u .
5) true if t is less or equal to u .
6) true if t is greater or equal to u .

Possible implementation 

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

Notes

These functions cannot be used to compare enums (including std::byte ), char , char8_t , char16_t , char32_t , wchar_t and bool .

Feature-test macro Value Std Feature
__cpp_lib_integer_comparison_functions 202002L (C++20) Integer comparison functions

Example

The example below might produce different signedness comparison warning if compiled without an appropriate warning suppression flag, e.g., -Wno-sign-compare (gcc/clang with -Wall -Wextra , see also SO: disabling a specific warning ).

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

See also

function object implementing x == y
(class template)
function object implementing x ! = y
(class template)
function object implementing x < y
(class template)
function object implementing x > y
(class template)
function object implementing x <= y
(class template)
function object implementing x >= y
(class template)
(C++20)
constrained function object implementing x == y
(class)
(C++20)
constrained function object implementing x ! = y
(class)
(C++20)
constrained function object implementing x < y
(class)
(C++20)
constrained function object implementing x > y
(class)
(C++20)
constrained function object implementing x <= y
(class)
(C++20)
constrained function object implementing x >= y
(class)
(C++20)
constrained function object implementing x <=> y
(class)
(C++20)
checks if an integer value is in the range of a given integer type
(function template)
provides an interface to query properties of all fundamental numeric types
(class template)
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/utility/intcmp&oldid=166103 "