c++ - 如何对多种类型进行一种明确的专业化？

Question

考虑如下的模板函数，如何为多种类型显式专门化一个版本的函数：

template <typename T>
void doSomething(){
 //whatever
}

目的是拥有一个专业而不是多个后续专业，因为 //something 是相同的：

void doSomething<int>(){
 //something
}
void doSomething<float>(){
 //something
}
void doSomething<double>(){
 //something
}

有什么方法可以实现一个专业化？

Answer 1

您不能使模板功能专业化。但是您可以将实现委托给一个辅助类，该类可以从您的函数中使用。一些骨架代码：

实现一个模板类并专门化它：

template< typename T, bool isArithmetic>
struct Something { void operator()() { ... } };

template< typename T, true>
struct Something { void operator()() { ... do something specialized for arithmetic types; } }

然后在模板函数中使用它：

template< typename T>
void myFunction()
{
   Something<T, IsArithmetic<T>::value>()();
}

其中 IsArithmetic 是一个提供关于类型 T（选择器）的信息的类。例如，您可以在 boost 库中找到此类类型信息。

Answer 2

你可以只使用一种 doSomethingImpl 函数。

template<typename T> doSomethingImpl() {
    // whatever
}
template<typename T> doSomething() {
    // something else
}
template<> doSomething<float>() {
    doSomethingImpl<float>();
}
template<> doSomething<int>() {
    doSomethingImpl<int>();
}

也可以更通用地进行专业化std::is_numeric<T>，例如使用 SFINAE 和 。

Answer 3

使用 c++ 2011（选项 -std=c++11），效果很好：

#include <iostream>

template <typename T>
struct unsignedObject
{
    unsignedObject() {
        std::cout << "instanciate a unsignedObject\n";
    }
};

struct signedObject
{
    signedObject() {
        std::cout << "instanciate a signedObject\n";
    }
};

template <typename T>
struct objectImpl
{
    typedef unsignedObject<T> impl; // optional default implementation (the line can be removed)
};

template <> struct objectImpl<unsigned char>  { typedef unsignedObject<unsigned char>  impl; };
template <> struct objectImpl<unsigned int>   { typedef unsignedObject<unsigned int>   impl; };
template <> struct objectImpl<unsigned short> { typedef unsignedObject<unsigned short> impl; };
template <> struct objectImpl<double>         { typedef signedObject   impl; };
template <> struct objectImpl<int>            { typedef signedObject   impl; };
template <> struct objectImpl<short>          { typedef signedObject   impl; };
template <> struct objectImpl<char>           { typedef signedObject   impl; };

template <typename T>
using object = typename objectImpl<T>::impl;

int main(void)
{
    object<int> x;    // x is a signedObject.
    object<double> y; // y is a signedObject.
    object<unsigned short> z; // z is a unsignedObject.
    return 0;
}