如何爲多種類型做一個明確的專業化？

Question

考慮像下面怎麼可能做到明確專門的功能，一個版本用於多種類型的模板函數：

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

的目的是有一個專業化而不是多個以下的人，因爲//東西是一樣的：

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

任何方法來實現一個專業？

Answer 1

你可以只是一種doSomethingImpl功能。

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

也有可能專攻更一般地，使用SFINAE和std::is_numeric<T>，例如。

Answer 2

你不能讓模板函數的專業化。但是你可以將這個實現委託給一個輔助類，它可以從你的函數中使用。一些框架代碼：

實現一個模板類，並專注它：

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 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; 
}