如何表示“大于 T 的最小整数类型”？

Question

假设我有一个整数类型 T（有符号或无符号）。我想（在编译时）引用最小的整数类型（有符号或无符号），例如，std::numeric_limits<T>::max() 加 1（我的意思是在非溢出意义上）。

什么是一个很好的通用方法？

Answer 1

对于无符号类型，这可以解决问题：

template <typename T>
constexpr unsigned size_in_bits() { return  sizeof(T) * CHAR_BIT; }

template <typename T>
using smallest_larger_uint_t = 
    typename boost::uint_t<size_in_bits<T>() + 1>::least;

如果我们想让某些东西适用于任何整数类型：

template <typename T, int NumBits>
using boost_integer_type = 
    typename std::conditional<
        std::is_unsigned<T>::value,
        boost::uint_t<NumBits>, 
        boost::int_t<NumBits>
    >::type;

template <typename T>
constexpr unsigned size_in_bits() { return sizeof(T) * CHAR_BIT; }

template <typename T>
using smallest_larger_integral_t = 
    typename boost_integer_type<T, size_in_bits<T>() + 1>::least;

有关int_t<N> 和uint_t<N> 的详细信息，请参阅documentation for Boost.Integer。

Answer 2

如果您希望某些东西在每种整数类型上都能正常工作，您可以将其嵌入到通过几个步骤构建的特征中。我们首先将整数类型映射到它们的位大小：

#define CREATE_SIGNED_META_OBJ(x) template <>\
    struct signed_integer_type<x> {\
        typedef int##x##_t type;\
    };

#define CREATE_UNSIGNED_META_OBJ(x) template <>\
    struct unsigned_integer_type<x> {\
        typedef uint##x##_t type;\
    };

template <std::size_t length>
struct signed_integer_type;

template <std::size_t len>
struct unsigned_integer_type;

CREATE_SIGNED_META_OBJ(8)
CREATE_SIGNED_META_OBJ(16)
CREATE_SIGNED_META_OBJ(32)
CREATE_SIGNED_META_OBJ(64)

CREATE_UNSIGNED_META_OBJ(8)
CREATE_UNSIGNED_META_OBJ(16)
CREATE_UNSIGNED_META_OBJ(32)
CREATE_UNSIGNED_META_OBJ(64)

然后，可以构建特征本身。我们想将我们的二分法应用于断言std::numeric_limits<Int>::min() == 0...

template <typename Int, bool>
struct get_smallest_for_max_plus_one;

template <typename Int>
struct get_smallest_for_max_plus_one<Int, true> {
    typedef typename signed_integer_type<2*sizeof(Int)*8>::type type;
};

template <typename Int>
struct get_smallest_for_max_plus_one<Int, false> {
    typedef typename unsigned_integer_type<sizeof(Int)*8>::type type;
};

template <typename Int>
using get_fittest_int_type = get_smallest_for_max_plus_one<Int, std::numeric_limits<Int>::min() == 0>;

现在我们可以直接将get_fittest_int_type 与任何整数一起使用...运行示例可以在Coliru 上找到。

不过，为了保持一致性，我想您想保留 signed 或 unsigned 属性...如果是这种情况，您可以将 get_smallest_for_max_plus_one 的特化替换为以下内容：

// Unsigned type, we want to get the smallest unsigned type that can hold max + 1
template <typename Int>
struct get_smallest_for_max_plus_one<Int, true> {
    typedef typename unsigned_integer_type<2*sizeof(Int)*8>::type type;
};

// Signed type, we want the smallest signed type that can hold max + 1
template <typename Int>
struct get_smallest_for_max_plus_one<Int, false> {
    typedef typename signed_integer_type<2*sizeof(Int)*8>::type type;
};

Answer 3

您可以按所需大小指定整数并进行相应选择：

#include <cstdint>

namespace Detail {
    template <std::size_t> struct integer_of_size_undefined {};
    template <> struct integer_of_size_undefined<sizeof(int8_t)> {
        typedef int8_t type;
    };
    template <> struct integer_of_size_undefined<sizeof(int16_t)> {
        typedef int16_t type;
    };
    template <> struct integer_of_size_undefined<sizeof(int32_t)> {
        typedef int32_t type;
    };
    template <> struct integer_of_size_undefined<sizeof(int64_t)> {
        typedef int64_t type;
    };

    template <std::size_t> struct unsigned_integer_of_size_undefined {};
    template <> struct unsigned_integer_of_size_undefined<sizeof(int8_t)> {
        typedef uint8_t type;
    };
    template <> struct unsigned_integer_of_size_undefined<sizeof(int16_t)> {
        typedef uint16_t type;
    };
    template <> struct unsigned_integer_of_size_undefined<sizeof(int32_t)> {
        typedef uint32_t type;
    };
    template <> struct unsigned_integer_of_size_undefined<sizeof(int64_t)> {
        typedef uint64_t type;
    };
}

template <std::size_t N>
struct integer_of_size {
    typedef typename Detail::integer_of_size_undefined<N>::type type;
};

template <std::size_t N>
struct unsigned_integer_of_size {
    typedef typename Detail::unsigned_integer_of_size_undefined<N>::type type;
};


#include <type_traits>

template <typename T>
struct next_integer {
    typedef typename std::conditional<std::is_signed<T>::value,
        typename std::make_unsigned<T>::type,
        typename integer_of_size<2*sizeof(T)>::type>::type
        type;
};

int main ()
{
    static_assert(std::is_same<next_integer<std::int16_t>::type, uint16_t>::value,
        "Should be a unsigned 16 bit");
    static_assert(std::is_same<next_integer<std::uint16_t>::type, int32_t>::value,
        "Should be a signed 32 bit");

    return 0;
}

Answer 4

你可以这样做，使用来自cstdint的类型：

template <typename T>
struct next_type {
    typedef error_type type;
};

template <>
struct next_type<std::int32_t> {
    typedef std::uint32_t type;
}

template <>
struct next_type<std::uint32_t> {
    typedef std::int64_t type;
}

// Add more...

为每种类型添加专业化。然后使用它：

typename next_type<T>::type

因此，如果您已经使用了最大可能的类型，那么您将获得error_type，您必须以某种方式自己定义它是什么，否则它需要专门化。

使用cstdint 中的_least 类型可能会更好，例如std::int_least32_t 转到std::uint_least32_t。