我读过 C++ Primer，它说函数模板专业化是一个高级主题，但我完全迷失了。任何人都可以提供一个例子，为什么功能模板专业化很重要和必要？
为什么函数模板不支持偏特化，而类模板支持？底层逻辑是什么？
【问题讨论】：
s 而其他人使用z？
标签： c++ template-specialization
您关于为什么函数不支持偏特化的问题可以回答here。下面的代码展示了如何实现不同的特化。
template<typename T>
bool Less(T a, T b)
{
cout << "version 1 ";
return a < b;
}
// Function templates can't be partially specialized they can overload instead.
template<typename T>
bool Less(T* a, T* b)
{
cout << "version 2 ";
return *a < *b;
}
template<>
bool Less<>(const char* lhs, const char* rhs)
{
cout << "version 3 ";
return strcmp(lhs, rhs) < 0;
}
int a = 5, b = 6;
cout << Less<int>(a, b) << endl;
cout << Less<int>(&a, &b) << endl;
cout << Less("abc", "def") << endl;
【讨论】：
<int>。
我想不出一个例子，自从你问起我就一直在尝试。正如Jagannath 所指出的，long-standing advice 不是专门化函数，而是重载它们或使用特征类（可以专门化，甚至部分专门化）。
例如，如果你需要交换两个项目，那么依赖重载会更好（更可预测和更可扩展）：
template<class T>
void f() {
T a, b;
using std::swap; // brings std::swap into scope as "fallback"
swap(a, b); // unqualified call (no "std::") so ADL kicks in
// also look at boost::swap
}
以及如何为您的类型编写交换：
// the cleanest way to do it for a class template:
template<class T>
struct Ex1 {
friend void swap(Ex1& a, Ex1& b) { /* do stuff */ }
};
// you can certainly place it outside of the class instead---but in the
// same namespace as the class---if you have some coding convention
// against friends (which is common, but misguided, IMHO):
struct Ex2 {};
void swap(Ex2& a, Ex2& b) { /* do stuff */ }
两者都允许Argument Dependent Lookup (ADL)。
其他函数，例如 stringify/str 或 repr（表示）同样可以是非成员并通过重载利用 ADL：
struct Ex3 {
friend std::string repr(Ex3 const&) { return "<Ex3 obj>"; }
};
std::string repr(bool b) { return b ? "true" : "false"; }
// possible fallback:
template<class T>
std::string repr(T const& v) {
std::ostringstream out;
out << v;
return out.str();
}
// but in this particular case, I'd remove the fallback and document that
// repr() must be overloaded appropriately before it can be used with a
// particular type; for other operations a default fallback makes sense
换个角度看，如果函数模板可以作为特定实现的注册表，那就太好了，但是由于限制（在当前的 C++ 中，不确定 C++0x 到底是什么带到这里）它们不能像重载或类模板那样工作。
有一种方便但不重要的用法：轻松定义某些特化以放在单独的库中，可能是共享库（.so 或 .dll）。这很方便，因为它需要对通用模板进行最少的更改，但并不重要，因为它对我来说似乎很少见（在野外，而且在我的经验中当然很少见）并且实现者仍然可以使用重载或转发到完全专业化的类模板的非特化方法。
【讨论】：
friend std::string repr<Ex3>(Ex3 const&) { ... }) 不是吗？ （并且该模板需要在此之前定义或至少声明。）
repr() 提供的就地定义——是的，这是完全有效的。但是，如果您只给出了一个声明，并且预先声明了“后备”模板定义和适当的特化，那么标准要求（14.5.3）您的朋友声明使用 template-id （例如friend std::string repr<Ex3>(...);）或qualified-id（例如friend std::string N::repr(...);，并将模板放入命名空间N）。不幸的是，我发现编译器支持在我的测试中非常可疑......
template<class T> struct Ex4 { friend string repr(Ex4 const&) { return "<Ex4>"; } };。它相当直观（实际上与编写静态方法相同，只需使用 'friend'）并且不需要更多，这就是我建议默认编写此类重载的方式（与 Ex1 的交换相比）。
为了说明为什么函数模板专业化很重要，请考虑std::swap 模板函数。默认情况下，std::swap(x, y) 基本上是这样的：
T temp = x;
x = y;
y = temp;
但这可能效率低下，因为它涉及创建x 的额外副本，并且可以在分配中进行额外的复制。如果x 很大（例如，如果它是一个包含许多元素的std::vector），这尤其糟糕。此外，上述每一行都可能失败并引发异常，从而可能使x 和y 处于不良、不一致的状态。
为了解决这个问题，许多类都提供了自己的swap 方法（包括std::vector），这些方法可以交换指向其内部数据的指针。这样效率更高，并且可以保证永远不会失败。
但是现在您有一个案例，您可以在某些类型上使用std::swap(x, y)，但需要在其他类型上调用x.swap(y)。这很令人困惑，而且对模板不利，因为它们无法以通用、一致的方式交换两个对象。
但std::swap 可以专门化，以便在调用特定类型时调用x.swap(y)。这意味着您可以在任何地方使用std::swap，并且（希望）期望它表现良好。
【讨论】：
using std::swap; using-declaration，并使用 swap(a, b) 调用 ADL（参数相关查找）（注意前面没有“std::”）- --对于当前的 C++，这个结果比专门化 std::swap 更灵活、更通用。
std::swap 特化为std::vector 这种方式需要部分特化。啊。
基本上，您可以编写针对一般情况以通用方式运行的模板，但仍可以处理特殊情况。使用专业化的一个例子是std::vector。 std::vector<bool> 是一种封装bool 元素的特化，这样它们每个元素只使用一个位，而不是一个字节。 std::vector<T> 对于所有其他类型来说就像一个普通的动态数组。
专业化的更高级用途是元编程。例如，这里有一个示例（来自 Wikipedia），说明如何在编译时使用模板特化来计算阶乘。
template <int N>
struct Factorial
{
enum { value = N * Factorial<N - 1>::value };
};
template <>
struct Factorial<0>
{
enum { value = 1 };
};
【讨论】：