0

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

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

其中“I”是整数类型，“UI”应该是适当的无符号类型。例如，对于“I”这样的 64 位整数类型，“UI”应该是 64 位无符号整数类型。

我怎样才能做到这一点？

其次，我可以保证，“I”总是一个整数类型吗？

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

4

3 回答 3

3

恐怕在 VS2005 中你不能那么简单（我认为它不支持 C++11 到那种程度）。在 C++11 中，您可以使用std::is_signed< I >::value来检查是否I已签名并std::make_unsigned< I >::type获取相应的无符号类型。

于 2013-08-12T09:52:07.907 回答
3

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

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不是整数类型（您的专业存在的类型）编译将失败。

于 2013-08-12T10:02:24.420 回答
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
}
于 2013-08-12T10:07:14.460 回答