Question

所以给定一个函数f是否有办法为某些单独的非相关类定义特定行为，而没有一些宏-foo

e.g。替换/完成同样的事情的方式：

//p for param

template<typename T> 
T f(T p){ // some default op}; 

template<>
T f<float>(T p)
{ return 2*p; }

template<>
T f<double>(T p)
{ return 2*p; }

template<>
T f<int>(T p)
{ return 2*p; }

template<>
T f<std::string>(T p)
{ //return p copies of the string appended together; }

template<>
T f<std::vector>(T p)
{ //return the vector's element's copied}

// etc

不，我不喜欢正常的重载。理想情况下模板

if T in [int, float, double]
T f(T p) { return 2*p; }

否则//定义默认的其他行为。你可以在python中做。

无论如何根据T类决定？我能想到的一个可能的解决方案就是使用typeid和demangling。

出于某种原因，你说你有一个超级泛型函数和大约15个不同的类，写下所有使用重载都不会很漂亮。

Answer 1

如果我正确理解你的问题，你想要列出一个应该以不同于所有其他类型处理的类型列表？

如果是这种情况，请列出所需类型，并使用元函数确定T是否在返回true或false的类型列表中。

然后使用enable_if在函数实现之间切换。

#include <boost\mpl\vector.hpp>
#include <boost\mpl\contains.hpp>

typedef boost::mpl::vector<char,int,unsigned,long,unsigned long> types;
template<class T>
typename std::enable_if<boost::mpl::contains<types,T>::value, T>::type 
    foo(T t) 
{
    std::cout << "special foo\n";
    return t;
}

template<class T>
typename std::enable_if<boost::mpl::not_<boost::mpl::contains<types,T>>::type::value, T>::type 
    foo(T t) 
{
    std::cout << "normal foo\n";
    return t;
}
void main()
{
    foo(1);   //calls special foo because int is in the list
    foo(1.1); //calls normal foo because float is not in the list
}

更新： boost.MPL已过时，如果您使用C ++ 11支持brigand

Answer 2

在我看来，您需要相当正常（非模板）的函数重载：

float f(float p)
{ return 2*p; }

double f(double p)
{ return 2*p; }

int f(int p)
{ return 2*p; }

std::string f(std::string p)
{ //return p copies of the string appended together; }

std::vector f(std::vector p)
{ //return the vector's element's copied}

模板专业化类型列表没有宏？

2 个答案: