模板与泛型编程——重载与模板，可变函数模板，模板特例化

一、重载与模板

　　函数模板可以被另一个模板或普通非模板函数重载。与往常一样，名字相同的函数必须具有不同数量或类型的参数。

　　如果涉及函数模板，则函数匹配规则会在以下几方面受到影响：

• 对于一个调用，其候选函数包括所有模板实参推断成功的函数模板实例。
• 候选的函数模板总是可行的，因为模板实参推断会排除任何不可行的模板。
• 与往常一样，可行函数（模板与非模板）按类型转换（如果对此调用需要的话）来排序。当然，可以用于函数模板调用的类型转换是非常有限的。
• 与往常一样，如果恰有一个函数提供比任何其他函数都更好的匹配，则选择此函数。但是，如果有多个函数提供同样好的匹配，则：——如果同样好的函数中只有一个是非模板函数，则选择此函数。——如果同样好的函数中没有非模板函数，而有多个函数模板，且其中一个模板比其他模板更特例化，则选择此模板。——否则，调用有歧义。

二、可变函数模板

　　一个可变参数模板就是一个接受可变数目参数的模板函数或模板类。可变数目的参数被称为参数包。存在两种参数包：模板参数包，表示零个或多个模板参数；函数参数包，表示零个或多个函数参数。

　　我们用一个省略号来指出一个模板参数或函数参数表示一个包。在一个模板参数列表中，class...或typename ...指出接下来的参数表示零个或多个类型的列表；一个类型名后面跟一个省略号表示零个或多个给定类型的非类型参数的列表。在函数参数列表中，如果一个参数的类型是一个模板参数包，则此参数包也是一个函数参数包。

　　template<typename T, typename...args>
　　std::ostream &print(std::ostream &os, const T &t, const args &...rest);

args是一个模板参数包；rest是一个函数参数包。args表示零个或多个模板类型参数，rest表示零个或多个函数参数。

1）sizeof...运算符

　　当我们需要知道包中有多少元素时，可以使用sizeof...运算符。sizeof...返回一个常量表达式，而且不会对其实参求值。

　　template<typename T, typename...args>
　　std::ostream &print(std::ostream &os, const T &t, const args &...rest) {
　　　　std::cout << sizeof...(args) << std::endl; // 类型参数的数目
　　　　std::cout << sizeof...(rest) << std::endl; // 函数参数的数目
　　}

1、可变参数函数模板

　　当我们既不知道想要处理的实参的数目也不知道它们的类型时，可变参数函数是很有用的。

　　可变参数函数通常是递归的。第一步调用处理包中的第一个实参，然后用剩余实参调用自身。我们自定义的print函数也是这样的模式，每次递归调用将第二个实参打印到第一个实参表示的流中。为了终止递归，我们还需要定义一个非可变参数的print函数，它接受一个流和一个对象。

#include <iostream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
std::ostream &print(std::ostream &os, const T &t) {
    return os << t;
}

template<typename T, typename...args>
std::ostream &print(std::ostream &os, const T &t, const args &...rest) {
    os << t << ", ";
    return print(os, rest...); // 递归调用，打印其他实参
}
int main()
{
    print(std::cout, 2, 3.3, "hello");
    return 0;
}

2、包扩展

　　对于一个参数包，除了获取其大小外，我们能对它做的唯一的事情就是扩展它。当扩展一个包时，我们还要提供用于每个扩展元素的模式。扩展一个包就是将它分解为构造的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式右边放一个省略号（...）来触发扩展操作。

template<typename T, typename...args>
std::ostream &print(std::ostream &os, const T &t, const args &...rest) {
    os << t << ", ";
    return print(os, rest...); // 递归调用，打印其他实参
}

　　对args的扩展中，编译器将模式const args&应用到模板参数包args中的每个元素。因此，此模式的扩展结果是一个逗号分隔的零个或多个类型的列表，每个类型都形如const type&。

　　第二个扩展发生在对print的递归调用中。在此情况下，模式是函数参数包的名字（即rest）。此模式扩展出一个由包中元素组成的、逗号分隔的列表。

1）理解包扩展

　　C++语言还允许更复杂的扩展模式。例如，我们可以编写第二个可变参数，对其每个实参调用debug_rep，然后调用print打印string。

#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
std::ostream &print(std::ostream &os, const T &t) {
    return os << t;
}

template<typename T, typename...args>
std::ostream &print(std::ostream &os, const T &t, const args &...rest) {
    os << t << ", ";
    return print(os, rest...); // 递归调用，打印其他实参
}

template<typename T>
std::string debug_rep(const T &t) {
    std::ostringstream ret;
    ret << "-" << t << "-";
    return ret.str();
}

template<typename... args>
std::ostream &errorMsg(std::ostream &os, const args& ...rest) {
    return print(os, debug_rep(rest)...);
}
int main()
{
    errorMsg(std::cout, 2, 3.3, "hello");
    return 0;
}

3、转发参数包

三、模板特例化

　　编写单一模板，使之对任何可能的模板实参都是最合适的，都能实例化，这并不总是能办到。在某些情况下，通用模板的定义对特定类型是不合适的：通用定义可能编译失败或做得不正确。其他时候，我们也可以利用某些特定知识来编写更高效的代码，而不是从通用模板实例化。当我们不能（或不希望）使用模板版本时，可以定义类或函数模板的一个特例化版本。

1）定义函数模板特例化

　　当我们特例化一个函数模板时，必须为原模板中的每个模板参数都提供实参。为了指出我们正在实例化一个模板，应使用关键字template后跟一个空尖括号对（<>）。空尖括号指出我们将为原模板的所有模板参数提供实参。

template<>
void show(const char* const &x) { // show的特殊版本，处理字符数组的指针
    std::cout << x << "    second" << std::endl;
}

2）函数重载与模板实例化

　　当定义函数模板的特例化版本时，我们本质上接管了编译器的工作。即，我们为原模板的一个特殊实例提供了定义。重要的是要弄清：一个特例化版本本质上是一个实例，而非函数名的一个重载版本。

　　我们将一个函数定义为一个特例化版本还是一个独立的非模板函数，会影响到函数匹配。

　　注意：模板及其特例化版本应该声明在同一个头文件中。所有同名版本的声明应该放在前面，然后是这些模板的特例化版本。

　　将函数定义为特例化版本：

#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
void show(const T& x) {
    std::cout << x << "    first" << std::endl;
}

template<>
void show(const char* const &x) { // show的特殊版本，处理字符数组的指针
    std::cout << x << "    second" << std::endl;
}

template<std::size_t N>
void show(const char(&x)[N]) {
    std::cout << x << "    third" << std::endl;
}
int main()
{
    show("hi");
    return 0;
}

　　将函数定义为普通函数：

#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
void show(const T& x) {
    std::cout << x << "    first" << std::endl;
}

void show(const char* const &x) { 
    std::cout << x << "    second" << std::endl;
}

template<std::size_t N>
void show(const char(&x)[N]) {
    std::cout << x << "    third" << std::endl;
}
int main()
{
    show("hi");
    return 0;
}

3）类模板特例化

　　我们还可以特例化类模板。

#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
class Base {
public:
    Base(T x):data(x){}
    void show() {
        std::cout << "T" << std::endl;
    }
private:
    T data;
};
// Base的特例化版本
template<>
class Base<int> {
public:
    Base(int x) :data(x) {}
    void show() {
        std::cout << "int" << std::endl;
    }
private:
    int data;
};
int main()
{
    Base<std::string> sb("hi");
    sb.show();
    Base<int> ib(233);
    ib.show();
    return 0;
}

4）类模板部分特例化

　　与函数模板不同，类模板的特例化不必为所有模板参数提供实参。我们可以指定一部分而非所有模板参数，或是参数的一部分而非全部特性。一个类模板的部分特例化本身是一个模板，使用它时用户还必须为那些在特例化版本中未指定的模板参数提供实参。

　　我们只可以部分特例化类模板，而不能部分特例化函数模板。

　　由于一个部分特例化版本本质是一个模板，与往常一样，我们首先定义模板参数。类似任何其他特例版本，部分特例化版本的名字与原模板的名字相同。对每个未完全确定类型的模板参数，在特例化版本的模板参数列表中都有一项与之相应。在类名之后，我们要为特例化的模板参数指定实参，这些实参列于模板名之后的尖括号中。这些实参与原始模板中的参数按位置对应。

5）特例化成员

　　我们可以只特例化成员函数而不是特例化整个模板。

#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>

template<typename T>
class Base {
public:
    Base(T x):data(x){}
    void show() {
        std::cout << "T" << std::endl;
    }
private:
    T data;
};

template<>
void Base<int>::show() {
    std::cout << "int" << std::endl;
}
int main()
{
    Base<std::string> sb("hi");
    sb.show();
    Base<int> ib(233);
    ib.show();
    return 0;
}