Question

什么是完全类型安全且最灵活（以constexpr方式）比较两个通常意外（不同）类型的两个整数的方法？

Answer 1

这是一个想法：我们需要使用“通常的算术转换”：

如果两种类型都是无符号的，只需比较。
如果两种类型都已签名，只需比较。
如果签名不同且签名值为负，我们就完成了。
实际工作适用于两个值均为非负且具有不同符号的情况。当无符号值大于有符号类型的最大有符号值时，我们就完成了。否则，无符号值可以转换为带符号的类型而不更改值，并进行比较。

这是一次尝试：

#include <type_traits>
#include <limits>

template <bool SameSignedness> struct IntComparerImpl;

template <typename T, typename U>
constexpr bool IntCompare(T x, U y)
{
    return IntComparerImpl<std::is_signed<T>::value ==
                           std::is_signed<U>::value>::compare(x, y);
}

// same signedness case:
template <> struct IntComparerImpl<true>
{
    template<typename T, typename U>
    static constexpr bool compare(T t, U u)
    {
        return t < u;
    } 
};

// different signedness case:
template <> struct IntComparerImpl<false>
{
    // I1 is signed, I2 is unsigned
    template <typename I1, typename I2>
    static constexpr typename std::enable_if<std::is_signed<I1>::value, bool>::type
    compare(I1 x, I2 y)
    {
        return x < 0
            || y > std::numeric_limits<I1>::max()
            || x < static_cast<I1>(y);
    }

    // I1 is unsigned, I2 is signed
    template <typename I1, typename I2>
    static typename std::enable_if<std::is_signed<I2>::value, bool>::type
    compare(I1 x, I2 y)
    {
        return !(y < 0)
            && !(x > std::numeric_limits<I2>::max())
            && static_cast<I2>(x) < y;
    }
};

Answer 2

My own solution就是这个（基于N3485.pdf§5）：

#include <type_traits>
#include <limits>
#include <utility>

#include <cstdint>
#include <cstdlib>

template< typename L, typename R >
inline constexpr
typename std::enable_if< (std::is_signed< L >::value && !std::is_signed< R >::value), bool >::type
less(L const & lhs, R const & rhs)
{
    static_assert(std::is_integral< L >::value,
                  "lhs value must be of integral type");
    static_assert(std::is_integral< R >::value,
                  "rhs value must be of integral type");
    using T = typename std::common_type< L, R >::type;
    return (lhs < static_cast< L >(0)) || (static_cast< T const & >(lhs) < static_cast< T const & >(rhs));
}

template< typename L, typename R >
inline constexpr
typename std::enable_if< (!std::is_signed< L >::value && std::is_signed< R >::value), bool >::type
less(L const & lhs, R const & rhs)
{
    static_assert(std::is_integral< L >::value,
                  "lhs value must be of integral type");
    static_assert(std::is_integral< R >::value,
                  "rhs value must be of integral type");
    using T = typename std::common_type< L, R >::type;
    return !(rhs < static_cast< R >(0)) && (static_cast< T const & >(lhs) < static_cast< T const & >(rhs));
}

template< typename L, typename R >
inline constexpr
typename std::enable_if< (std::is_signed< L >::value == std::is_signed< R >::value), bool >::type
less(L const & lhs, R const & rhs)
{
    static_assert(std::is_integral< L >::value,
                  "lhs value must be of integral type");
    static_assert(std::is_integral< R >::value,
                  "rhs value must be of integral type");
    return lhs < rhs;
}

namespace
{

static_assert(less(1, 2), "0");
static_assert(less(-1, std::numeric_limits< std::uintmax_t >::max()), "1");
static_assert(less< std::int8_t, std::uintmax_t >(-1, std::numeric_limits< std::uintmax_t >::max()), "2");
static_assert(less< std::intmax_t, std::uint8_t >(-1, std::numeric_limits< std::uint8_t >::max()), "3");
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
static_assert(!(-1 < std::numeric_limits< unsigned long >::max()), "4");
#pragma GCC diagnostic pop
static_assert(less(-1, std::numeric_limits< unsigned long >::max()), "5");

}

int main()
{
        return EXIT_SUCCESS;
}

比较任意类型的整数

2 个答案: