在 C++ 中，如果您想对模板类中的单个方法进行部分特化，则必须对整个类进行特化（如 Template specialization of a single method from templated class with multiple template parameters 中所述）
然而，这在具有多个模板参数的较大模板类中变得令人厌烦，因为它们中的每一个都影响单个函数。使用 N 个参数，您需要将类专业化 2^N 次！
但是，对于 C++11，我认为可能会有更优雅的解决方案，但我不确定如何处理它。也许不知何故与enable_if？有什么想法吗？
【问题讨论】：
除了 Torsten 提出的基于继承的解决方案之外，您还可以使用 std::enable_if 和默认函数模板参数来启用/禁用函数的某些特殊化。
例如：
template<typename T>
struct comparer
{
template<typename U = T ,
typename std::enable_if<std::is_floating_point<U>::value>::type* = nullptr>
bool operator()( U lhs , U rhs )
{
return /* floating-point precision aware comparison */;
}
template<typename U = T ,
typename std::enable_if<!std::is_floating_point<U>::value>::type* = nullptr>
bool operator()( U lhs , U rhs )
{
return lhs == rhs;
}
};
我们利用SFINAE 根据模板参数禁用/启用函数的不同“特化”。因为SFINAE只能依赖函数参数，不能依赖类参数，所以我们需要一个可选的函数模板参数，它接受类的参数。
我更喜欢这种解决方案而不是基于继承的解决方案，因为：
但是对于没有实现可选函数模板参数的编译器（如 VS2012 中的 MSVC），这个解决方案不起作用，你应该使用基于继承的解决方案。
编辑：您可以使用其他委托工作的函数来包装模板函数的非实现默认函数模板参数：
template<typename T>
struct foo
{
private:
template<typename U>
void f()
{
...
}
public:
void g()
{
f<T>();
}
};
当然，编译器可以轻松内联 g() 丢弃包装调用，因此这种替代方案不会影响性能。
【讨论】：
一种解决方案是从函数转发，您希望重载到依赖于类模板参数的某些实现：
template < typename T >
struct foo {
void f();
};
template < typename T >
struct f_impl {
static void impl()
{
// default implementation
}
};
template <>
struct f_impl<int> {
static void impl()
{
// special int implementation
}
};
template < typename T >
void foo< T >::f()
{
f_impl< T >::impl();
}
或者只是使用私有函数，使用模板参数调用它们并重载它们。
template < typename T >
class foo {
public:
void f()
{
impl(T());
}
private:
template < typename G >
void impl( const G& );
void impl( int );
};
或者，如果真的只是一种特殊情况，具有非常特殊的类型，只需在实现中查询该类型即可。
【讨论】：
使用 enable_if：
#include <iostream>
#include <type_traits>
template <typename T>
class A {
private:
template <typename U>
static typename std::enable_if<std::is_same<U, char>::value, char>::type
g() {
std::cout << "char\n";
return char();
}
template <typename U>
static typename std::enable_if<std::is_same<U, int>::value, int>::type
g() {
std::cout << "int\n";
return int();
}
public:
static T f() { return g<T>(); }
};
int main(void)
{
A<char>::f();
A<int>::f();
// error: no matching function for call to ‘A<double>::g()’
// A<double>::f();
return 0;
}
【讨论】：
U模板参数的默认值了。否则你的电话应该是A<char>::f<char>();，这是没有意义的。
标签调度通常是执行此操作的简洁方式。
在您的基础方法中，使用特征类来确定您要调用的方法的子版本。这会生成一个描述决策结果的类型（称为标签）。
然后完美转发到传递标签类型实例的实现子版本。重载解决方案启动，只有您想要的实现被实例化和调用。
基于参数类型的重载解析是处理调度的一种不那么疯狂的方式，因为enable_if 是脆弱的，在使用时很复杂，如果你有 3 次以上的重载，就会变得非常复杂，并且存在奇怪的极端情况编译错误会让您大吃一惊。
【讨论】：
也许我错了，但 Manu343726 提供的选择的最佳 anwser 有错误，无法编译。两个运算符重载都有相同的签名。考虑有问题的最佳答案std::enable_if : parameter vs template parameter
附：我会发表评论，但没有足够的声誉，对不起
【讨论】：
enable_if<is_floating_point，另一个是enable_if<!is_floating_point。在所有情况下，都将启用这两个运算符中的一个。