"T보다 큰 최소 적분 유형"을 표현하는 방법은 무엇입니까?

Question

정수형이 T (signed 또는 unsigned)라고 가정합니다. 필자는 (컴파일 타임에) std::numeric_limits<T>::max()에 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; 

을 우리가 뭔가 정수 유형에 대해 작업 할 경우 : 서명되지 않은 유형의

Answer 1

,이 트릭을 수행

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

당신은 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을 받고 가능한 최대 유형을 사용 그래서 경우는 true, 그렇지 않은 경우는 전문화됩니다.

이 std::uint_least32_t과 같이 cstdint에서 _least 유형을 사용하는 것이 더 나을 것입니다.

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

, 당신은 여러 단계로 구축 된 특성이 포함 할 수 있습니다. 우리는 비트 형식으로 정수형을 매핑하는 것으로 시작합니다 :

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

그런 다음 특성을 자체적으로 작성할 수 있습니다. 우리는

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을 사용할 수 있습니다 ... 주장 std::numeric_limits<Int>::min() == 0의 값에 우리의 이분법을 적용 할 ... 실행 예 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; 
};