Question

我正在使用Visual Studio 2005，我有这样的方法/功能：

template<typename I>
void MyFunction(I &value)
{
    //some operations
    UI unsigned_type = static_cast<UI>(value);
}

“I”是整数类型，“UI”应该是适当的用户类型。例如，对于64位整数类型作为“I”，“UI”应该是64位无符号整数类型。

我该怎么做？

其次，我可以保证，“我”将始终是整数类型吗？

第三，我不能使用Boost;）。

Answer 1

我担心在VS2005中你不能那么直截了当（我认为它不支持C ++ 11）。在C ++ 11中，您可以使用std::is_signed< I >::value检查I是否已签名，使用std::make_unsigned< I >::type获取相应的无符号类型。

Answer 2

您可以为自己实现类型特征。使用的库可能会更好，但是当您无法使用时，您必须自己动手：

template<class T> 
struct make_unsigned; // no implementation

template<>
struct make_unsigned<int>
{
  typedef unsigned int type;
};

template<>
struct make_unsigned<unsigned int>
{
  typedef unsigned int type;
};

// and all other types you need ... (possibly implemented with help of a macro)

并在您的代码中：

template<typename I>
void MyFunction(I &value)
{
    //some operations

    typedef make_unsigned<I>::type UI; 
    UI unsigned_type = static_cast<UI>(value);
}

当然这并不完美，但错误会在代码编译时出现，您可以修复它。

编辑： 如果I不是整数类型（存在专门化的类型），则编译将失败。

Answer 3

如果你不能使用boost，你别无选择，只能自己实现一些类型特征机制。这可能有点乏味，但是你可以这样做：

// convinience base classes
template<typename T, T Value>
struct constant { static const T value = Value; };

typedef constant<bool, true> true_type;
typedef constant<bool, false> false_type;

// a trait to check if two types are the same
template<typename T, typename U>
struct is_same : false_type {};
template<typename T>
struct is_same<T,T> : true_type{};

// a trait to check if type is integral, based on is_same
// it's missing wchar_t and bool
#define SAME(T,U) is_same<T,U>::value
template<typename T>
struct is_integral : constant<bool,SAME(T,char) ||
                                   SAME(T,signed char) ||
                                   SAME(T,unsigned char) ||
                                   SAME(T,short) ||
                                   SAME(T,unsigned short) ||
                                   SAME(T,int) ||
                                   SAME(T,unsigned int) ||
                                   SAME(T,long) ||
                                   SAME(T,unsigned long) ||
                                   SAME(T,long long) ||
                                   SAME(T,unsigned long long)> {};

// Trait class to change a type to its unsigned variant.
// The base template simply forwards the type, specializations do the work.

template<typename T>
struct identity { typedef T type; };

template<typename T>
struct make_unsigned : identity<T> {};

template<> struct make_unsigned<signed char> : identity<unsigned char>{};
template<> struct make_unsigned<short>       : identity<unsigned short>{};
template<> struct make_unsigned<int>         : identity<unsigned int>{};
template<> struct make_unsigned<long>        : identity<unsigned long>{};
template<> struct make_unsigned<long long>   : identity<unsigned long long>{};

// Utility class to enable overloads based on some compile time condition
template<bool B, typename = void>
struct enable_if { };
template<typename T>
struct enable_if<true, T> {
    typedef T type;
};

// Only enable this function if I is integral
template<typename I>
typename enable_if<is_integral<I>::value>::type MyFunction(I &value)
{
    typename make_unsigned<I>::type ui;
}

int main()
{
    int i;
    MyFunction(i); // ok
    float f;
    MyFunction(f); // fails
}

C ++模板整数类型足够无符号类型

3 个答案: