【探寻C++之旅】第五章：模板

请君浏览 前言1. 泛型编程2. 函数模板2.1 函数模板的概念2.2 函数模板的格式2.3 函数模板的原理2.4 函数模板的实例化2.5 模板参数的匹配原则 3. 类模板3.1 类模板的定义格式3.2 类模板的实例化 4. 非类型模板参数5. 模板的特化5.1 特化的概念5.2 函数模板特化5.3 类模板特化5.4 特化的小结 6. 模板分离编译6.1 什么是分离编译6.2 模板的分离编译 7. 模板总结尾声

前言

今天，我们继续踏入追寻C++的冒险历程。上一章我们简单介绍并且了解了C++中的内存管理，那么本章将为大家讲解C++中另一重要的部分：模板。下面让我们一起来进入模板的学习。

1. 泛型编程

在C语言中，当我们实现一个交换函数时只能规定一种类型，若是想要实现不同类型的交换函数需要写出不同名字的交换函数，在C++中我们可以通过函数重载来实现同一个函数名去调用不同的类型。

void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double& left, double& right) { double temp = left; left = right; right = temp; } void Swap(char& left, char& right) { char temp = left; left = right; right = temp; }

使用函数重载虽然可以实现，但是有一下几个不好的地方：

重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。代码的可维护性比较低，一个出错可能所有的重载均出错。

那么有没有什么更好的解决方法呢？聪明的你是否能想到可不可以制造一个模具，可以通过使用各种不同的材料才制作一个同样外形的东西，就如同制作月饼一样，一个相同的模具可以通过使用不同颜色的面团来制作不同口味但样式相同的月饼。

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同颜色和口味的月饼(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。这就是泛型编程。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板分为两类：

一是函数模板二是类模板

下面我们将一一进行介绍。

2. 函数模板 2.1 函数模板的概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2 函数模板的格式

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名(参数列表){}

template代表这是一个模板，后面跟一对尖括号，里面定义模板参数。typename是用来定义模板参数的关键字，也可以使用class（切记：不能使用struct替代）。具体实现如下面代码所示：

template<typename T> void Swap( T& left, T& right) { T temp = left; left = right; right = temp; } 2.3 函数模板的原理

函数模板是一个蓝图（可以类比一下类和对象），它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T> T Add(const T& left, const T& right) { return left + right; } int main() { int a1 = 10, a2 = 20; double d1 = 10.0, d2 = 20.0; Add(a1, a2); Add(d1, d2); /* 该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有 一个T， 编译器无法确定此处到底该将T确定为int 或者 double类型而报错 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要 背黑锅 Add(a1, d1); */ // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化 Add(a, (int)d); return 0; }

显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void) { int a = 10; double b = 20.0; // 显式实例化 Add<int>(a, b); return 0; }

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

2.5 模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数 int Add(int left, int right) { return left + right; } // 通用加法函数 template<class T> T Add(T left, T right) { return left + right; } void Test() { Add(1, 2); // 与非模板函数匹配，编译器不需要特化 Add<int>(1, 2); // 调用编译器特化的Add版本 }

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数 int Add(int left, int right) { return left + right; } // 通用加法函数 template<class T1, class T2> T1 Add(T1 left, T2 right) { return left + right; } void Test() { Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化 Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数 }

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

3. 类模板 3.1 类模板的定义格式 template<class T1, class T2, ..., class Tn> class 类模板名 { // 类内成员定义 };

跟函数模板的定义一致，在类上面加上一句template<模板参数>即可。

#include<iostream> using namespace std; // 类模版 template<typename T> class Stack { public: Stack(size_t capacity = 4) { _array = new T[capacity]; _capacity = capacity; _size = 0; } void Push(const T& data); private: T* _array; size_t _capacity; size_t _size; }; // 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误 template<class T> void Stack<T>::Push(const T& data) { // 扩容 _array[_size] = data; ++_size; } int main() { Stack<int> st1; // int Stack<double> st2; // double return 0; } 3.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// Stack是类名，Stack<int>才是类型 Stack<int> st1; // int Stack<double> st2; // double 4. 非类型模板参数

模板参数分为类型形参与非类型形参。

类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称（上面所有的代码中出现的模板参数都为类型形参）。非类型形参： 用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。 namespace bite { // 定义一个模板类型的静态数组 template<class T, size_t N = 10> class array { public: T& operator[](size_t index) { return _array[index]; } const T& operator[](size_t index) const { return _array[index]; } size_t size() const { return _size; } bool empty() const { return 0 == _size; } private: T _array[N]; size_t _size; }； }

注意：

类对象以及字符串是不允许作为非类型模板参数的（浮点数在C++20后支持）。非类型的模板参数必须在编译期就能确认结果。 5. 模板的特化 5.1 特化的概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板：

// 函数模板 -- 参数匹配 template<class T> bool Less(T left, T right) { return left < right; } int main() { cout << Less(1, 2) << endl; // 可以比较，结果正确 Date d1(2022, 7, 7); Date d2(2022, 7, 8); cout << Less(d1, d2) << endl; // 可以比较，结果正确 Date* p1 = &d1; Date* p2 = &d2; cout << Less(p1, p2) << endl; // 可以比较，结果错误 return 0; }

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

5.2 函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板关键字template后面接一对空的尖括号<>函数名后跟一对尖括号，尖括号中指定需要特化的类型函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。 // 函数模板 -- 参数匹配 template<class T> bool Less(T left, T right) { return left < right; } // 对Less函数模板进行特化 template<> bool Less<Date*>(Date* left, Date* right) { return *left < *right; } int main() { cout << Less(1, 2) << endl; Date d1(2022, 7, 7); Date d2(2022, 7, 8); cout << Less(d1, d2) << endl; Date* p1 = &d1; Date* p2 = &d2; cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了 return 0; }

一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

bool Less(Date* left, Date* right) { return *left < *right; }

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。

5.3 类模板特化

类模板特化分为两类，一类是全特化，一类是偏特化。

全特化：全特化即是将模板参数列表中所有的参数都确定化。

//普通模板 template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; }; //特化模板 template<> class Data<int, char> { public: Data() {cout<<"Data<int, char>" <<endl;} private: int _d1; char _d2; }; int main() { Data<int, int> d1; Data<int, char> d2; return 0; }

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; };

偏特化有以下两种表现方式：

部分特化：参数更进一步的限制

// 将第二个参数特化为int template <class T1> class Data<T1, int> { public: Data() {cout<<"Data<T1, int>" <<endl;} private: T1 _d1; int _d2; };

参数更进一步的限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型 template <typename T1, typename T2> class Data <T1*, T2*> { public: Data() {cout<<"Data<T1*, T2*>" <<endl;} private: T1 _d1; T2 _d2; }; //两个参数偏特化为引用类型 template <typename T1, typename T2> class Data <T1&, T2&> { public: Data(const T1& d1, const T2& d2) : _d1(d1) , _d2(d2) { cout<<"Data<T1&, T2&>" <<endl; } private: const T1 &_d1; const T2 &_d2; }; int main() { Data<double , int> d1; // 调用特化的int版本 Data<int , double> d2; // 调用基础的模板 Data<int*, int*> d3; // 调用特化的指针版本 Data<int&, int&> d4(1, 2); // 调用特化的指针版本 }

在上面的代码中我们可以看到，在将两个参数偏特化为指针类型后原本的模板参数T1和T2的类型并不是变为了指针，而还是原类型，这样使我们可以在编写程序时更加灵活。当参数类型既满足全特化也满足偏特化编译器优选选择全特化。

有如下专门用来按照小于比较的类模板Less：

#include<vector> #include<algorithm> //下面的Less类也被称为仿函数（下篇会进行讲解） template<class T> struct Less { bool operator()(const T& x, const T& y) const { return x < y; } }; int main() { Date d1(2022, 7, 7); Date d2(2022, 7, 6); Date d3(2022, 7, 8); vector<Date> v1; v1.push_back(d1); v1.push_back(d2); v1.push_back(d3); // 可以直接排序，结果是日期升序 sort(v1.begin(), v1.end(), Less<Date>()); vector<Date*> v2; v2.push_back(&d1); v2.push_back(&d2); v2.push_back(&d3); // 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序 // 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象 // 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期 sort(v2.begin(), v2.end(), Less<Date*>()); return 0; }

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照*Less*模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化 template<> struct Less<Date*> { bool operator()(Date* x, Date* y) const { return *x < *y; } };

特化之后，在运行上述代码，就可以得到正确的结果。

5.4 特化的小结

一般来说，在函数模板中不建议使用特化，此时的进行一个函数重载会更加的简洁高效。

6. 模板分离编译 6.1 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

6.2 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h template<class T> T Add(const T& left, const T& right); // a.cpp template<class T> T Add(const T& left, const T& right) { return left + right; } // main.cpp #include"a.h" int main() { Add(1, 2); Add(1.0, 2.0); return 0; }

分析：

我们知道，当模板没有实例化时在编译中是不会出现具体的代码的，因此在main.cpp中无法找到Add函数的具体代码，导致链接时报错，那么我们应该怎么做呢？有下面的几个办法可以解决这个问题：

将声明和定义放到一个文件 “xxx.h” 里面(或者叫xxx.hpp，里面都为模板)。（推荐使用这种）

模板定义的位置显式实例化。(这种方法不实用，不推荐使用)

//显示实例化的格式 template int Add(const int& left, const int& right); 7. 模板总结

【优点】

模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。

【缺陷】

模板会导致代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。 尾声

若有纰漏或不足之处欢迎大家在评论区留言或者私信，同时也欢迎各位一起探讨学习。感谢您的观看！