Question

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

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

目的是有一个专门化而不是多个跟随者，因为//某些东西是相同的：

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

任何实现一次专业化的方法？

Answer 1

您无法进行模板功能专业化。但是您可以在helper类中委托实现，可以从您的函数中使用。一些骨架代码：

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

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

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

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

如何对多种类型进行一次显式专业化？

3 个答案: