C++ 模板系列小结01-函数模板和类模板

技术答疑，成长进阶，可以加入我的知识星球：音视频领域专业问答的小圈子

现如今，掌握 C++ 模板技巧并且熟练使用可以说是能力进阶的必备内容了。

在一些优秀的开源项目中经常能看到模板的使用，要是不了解其使用方法，对分析源码都会有些阻碍。

推荐阅读《C++ Templates 中文版》一书，或许可以让你对 C++ 模板有个更加系统的概念，同时辅助阅读网上相关的博客文章加深理解，在代码实践中去掌握提高。

C++ 模板主要可以分为函数模板和类模板，这次就是介绍它们两个。

函数模板

函数模板主要就是将它的参数用类型带代替，对每个不同的类型都会生成对应的函数，所以函数模板可以用多种不同的类型进行调用，它代表的其实是一个函数家族而不是一个函数。

以下是个简单的函数模板示例：

 1#include <iostream>
 2
 3template <typename T>
 4T plus(T a,T b){
 5    return a+b;
 6}
 7
 8// 使用引用类型，减少拷贝操作
 9template<typename T>
10inline T const &max(T const &a, T const &b) {
11    return a < b ? b : a;
12}
13
14int main() {
15    plus(1.0, 1.0);
16    plus(static_cast<int>(1.0), 2);
17    plus<int>(2.0, 3.0);
18
19    max(2,1);
20    max(static_cast<int>(2.0),1);
21    max<double>(2.0,3.0);
22    return 0;
23}
CPP

通常而言，并不是把模板编译成一个可以处理任何单一类型的单一实体，而是针对实例模板参数的每种类型，都从模板产生一个不同的实体。

针对上面的使用，整型和浮点型都生成了一个对应的函数。

对于函数模板的参数，是可以在调用时显示指定的，另外可以在调用时对类型做强制类型转换，这是因为模板不允许自动类型转换，所以需要我们手动来完成。

函数模板的重载

和普通函数一样，函数模板也可以重载，也就是相同函数名称可以具有不同的函数定义。

 1inline int const &max(int const &a, int const &b) {
 2    return a < b ? b : a;
 3}
 4
 5template<typename T>
 6inline T const &max(T const &a, T const &b) {
 7    return a < b ? b : a;
 8}
 9
10template<typename T>
11inline T const &max(T const &a, T const &b, T const &c) {
12    return ::max(::max(a,b),c);
13}
CPP

如上所示，一个非函数模板可以合一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非函数模板。

对于非函数模板和同名的函数模板，如果其他条件都相同的话，那么在调用的时候，重载解析过程通常会调用非函数模板，而不会从该模板产生一个实例。

对于函数的重载，一般来说改变的内容最好是下面两种情况：

改变参数的数目
显示地指定模板参数

遵循以上两点，避免在重载函数调用过于复杂，从而导致匹配出差。

类模板

与函数模板相似，类可以被一种或者多种类型参数化。

以下代码是一个简单的类模板示例：

 1template<typename T>
 2class Stack {
 3private:
 4    std::vector<T> elems;
 5public:
 6        void push(T const&);
 7        void pop();
 8        T top() const;
 9        bool empty() const{
10            return elems.empty();
11        }
12};
13
14template<typename T>
15void Stack<T>::push(const T & elem) {
16    elems.push_back(elem);
17}
18
19template<typename T>
20void Stack<T>::pop() {
21    if (!elems.empty()){
22        elems.pop_back();
23    }
24}
25
26template<typename T>
27T Stack<T>::top() const {
28    if (!elems.empty()){
29        return elems.back();
30    }
31    throw std::out_of_range("Stack::top(); empty Stack");
32}
33
34int main() {
35    Stack<int> intStack;
36    intStack.push(1);
37    intStack.top();
38    intStack.pop();
39    return 0;
40}
CPP

类模板的声明和函数模板声明很类似，在声明之前都用 typename 声明作为类型参数的标识符。

在定义类模板的成员函数时，关于成员函数的实现，可以在类声明里面去实现，也可以放到外面去实现。

如果是在类外面声明的，那么必现要指定该成员函数是一个函数模板，而且还需要使用这个类模板的完整类型限定符。

另外，只有那些被调用的成员函数，才会产生这些函数的实例化代码。

类模板的特化

可以使用模板实参来特化类模板。

和函数模板的重载类似，通过特化类模板，可以优化基于某种特定类型的实现，或者克服某种特定类型在实例化类模板时所出现的不足。

另外，如果要特化一个类模板，还要特化该类模板的所有成员函数。虽然也可以只特化某个成员函数，但这个做法并没有特化整个类，也就没有特化整个类模板。

为了特化一个类模板，必须在起始处声明一个 template<> ，接下来声明用特化类模板的类型。

如下代码所示：

 1template<>
 2class Stack<std::string> {
 3private:
 4        std::deque<std::string> elems;
 5public:
 6        void push(std::string const&);
 7        void pop();
 8        std::string top() const;
 9        bool empty() const{
10            return elems.empty();
11        }
12};
13
14void Stack<std::string>::push(const std::string &elem) {
15    elems.push_back(elem);
16}
17
18void Stack<std::string>::pop() {
19    if (!elems.empty()){
20        elems.pop_back();
21    }
22}
23
24std::string Stack<std::string>::top() const {
25    if (!elems.empty()){
26        return elems.back();
27    }
28    throw std::out_of_range("Stack<std::string>::top(); empty Stack");
29}
30
31int main() {
32    Stack<std::string> stringStack;
33    intStack.push("string");
34    intStack.top();
35    intStack.pop();
36    return 0;
37}
CPP

进行类模板的特化时，每个成员函数都必须重新定义为普通函数，原来函数模板中的每个 T 也相应地被进行特化的类型取代。

局部特化

上面的特化可以称之为全特化，另外类模板还可以局部特化，在特定的环境下制定类模板的实现，并且要求某些模板参数仍然必须由用户来定义。

如下代码所示：

 1template<typename T1,typename T2>
 2class MyClass{
 3
 4};
 5
 6// 局部特化，两个模板参数具有相同的类型
 7template<typename T>
 8class MyClass<T,T>{
 9
10};
11
12// 局部特化， 第二个模板参数的类型是 int
13template<typename T>
14class MyClass<T,int>{
15
16};
17
18// 局部特化，两个模板参数都是指针类型
19template<typename T1,typename T2>
20class MyClass<T1*,T2*>{
21
22};
CPP

对于局部特化，其成员函数同样要指定是模板函数，并且要使用特化后的类模板完整类型限定符。

缺省模板实参

对于类模板，可以为类模板参数定义默认值。这些值就被称为缺省模板实参，而且它们还可以引用之前的目标参数。

如下代码所示：

 1template <typename T,typename CONT = std::vector<T> >
 2class MyStack{
 3private:
 4    CONT elems;
 5public:
 6    void push(T const&);
 7    void pop();
 8    T top() const;
 9    bool empty() const{
10        return elems.empty();
11    }
12};
13
14template<typename T, typename CONT>
15void MyStack<T, CONT>::push(const T &elem) {
16    elems.push_back(elem);
17}
18
19template<typename T, typename CONT>
20void MyStack<T, CONT>::pop() {
21    if (!elems.empty()){
22        elems.pop_back();
23    }
24}
25
26template<typename T, typename CONT>
27T MyStack<T, CONT>::top() const {
28    if (!elems.empty()){
29        return elems.back();
30    }
31    throw std::out_of_range("MyStack<>::top(); empty Stack");
32}
33
34int main() {
35    MyStack<int> intMyStack;
36    intMyStack.push(1);
37    intMyStack.top();
38    intMyStack.pop();
39
40    MyStack<double, std::deque<double>> doubleMyStack;
41    doubleMyStack.push(0.1);
42    doubleMyStack.top();
43    doubleMyStack.pop();
44    return 0;
45}
CPP

以上代码中，如果不传递第二个模板参数，那么就使用默认的 vector 来管理元素。如果传了，就使用指定的类型来管理元素。

小结

以上就是关于 C++ 模板中函数模板和类模板的小总结，基本上还是很容易理解的，就是用模板参数 T 代替具体的类型，并且还可以对函数模板进行重载，对类模板进行特化，类模板还可以指定默认类型参数。

欢迎关注微信公众号：音视频开发进阶