C++ 如何对多个类型进行一次显式专门化？

考虑到下面这样的模板函数，如何能够显式地将一个版本的函数专门化为多个类型：

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

模板
无效剂量测定法（）{
//随便
}

其目的是要有一个专门化，而不是多个以下专门化，因为//有些东西是相同的：

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

void doSomething（）{
//某物
}
无效剂量测定法（）{
//某物
}
无效剂量测定法（）{
//某物
}

---

任何实现一种专门化的方法？

您可以只使用一种doSomethingImpl函数

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

模板doSomethingImpl（）{
//随便
}
模板剂量测定法（）{
//别的
}
模板剂量测定法（）{
doSomethingImpl（）；
}
模板剂量测定法（）{
doSomethingImpl（）；
}

---

还可以使用SFINAE和std:：is_numeric等进行更一般的专门化。

您不能进行模板函数专门化。但是您可以在助手类中委托实现，该类可以从您的函数中使用。一些基本代码：

实现模板类并对其进行专门化：

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

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

template
结构某物{void operator（）（{…}}）；
模板
struct Something{void operator（）

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

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

模板
void myFunction（）
{
某物（）；
}

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

< P>使用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;
}

#包括
模板
结构unsignedObject
{
unsignedObject（）{
std：：使用
enable\u if
和重载，你绝对可以。但我同意委托给（专门的）结构通常更干净。@Konrad Rudolph\u事实上唯一的方法似乎是使用enable\u if.@Pooria:是-使用
enable\u if
和重载指的是一种技术，而不是两种不同的技术。还应该注意的是，在幕后，
enable_if
只是将SFINAE与专用助手结构结合使用，就像在Cătălin的示例中一样。您仍在对每种类型进行单独的专用化。@Pooria:但您不必维护它我在回答中说，如果你想找更通用的东西，你可以试试std:：is_numeric@Puppy那么，你能举一个如何使用std:：is_numeric的例子吗？你会如何调用这些函数来获得所需的专门化？@TokenMacGuy_不明白你的意思！