【C++进阶】模板进阶

👦个人主页：@Weraphael
✍🏻作者简介：目前学习C++和算法
✈️专栏：C++航路
🐋 希望大家多多支持，咱一起进步！😁
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注✨

---

前言

初阶模板地址：点击跳转

一、typename和class的区别

在以前博客我们说过，定义模板参数关键字可以用typename，也可以用class，它们是没有区别的，可是真的没有区别吗？来看看以下这个例子

假设要打印容器的数据，要封装一个打印函数（以迭代器的方式）

#include <iostream>
#include <vector>
using namespace std;void Print(const vector<int>& v)
{vector<int>::const_iterator it = v.begin();while (it != v.end()){cout << *it << ' ';it++;}cout << endl;
}int main()
{vector<int> v{ 10,20,30,40,50 };Print(v);return 0;
}

【输出结果】

以上代码虽然可以正常输出，但它只能打印vector<int>类型容器的数据，若要打印vector<double>，又或者是list容器的数据，那么这样就写死了，有人想可以用函数模板。

代码如下：

#include <iostream>
#include <vector>
using namespace std;// 把class换成typename也是可以的
template<class Container>
void Print(const Container& v)
{Container::const_iterator it = v.begin();while (it != v.end()){cout << *it << ' ';it++;}cout << endl;
}int main()
{vector<int> v{ 10,20,30,40,50 };Print(v);return 0;
}

【输出结果】

使用函数模板后发现以上代码报错了，提示说需要在Container前加上typename

那么为什么必须要加上typename呢？

这是因为编译器在编译的时候是从上往下的，当编译到Container::const_iterator it时，Container还没实例化，那么此时编译器区分不了Container是类型还是类对象（静态成员变量Container::const_iterator）。vector<int>是实例化出来的，加上域作用限定符::去找其内嵌类型(迭代器)，所以不会报错。因此，编译器要求加上typename告诉Container是类型。

二、非类型模板参数

2.1 概念

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

• 类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

• 非类型形参：将常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

举个例子：定义一个模板类型的静态数组

#include <iostream>
#include <vector>
using namespace std;// size_t N = 10 - 非类型形参
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;
};

需要注意的是，非类型模板参数必须满足以下两点：

1. 必须是常量，不可被修改
2. 必须是整型。整型家族有：char、short、bool、int、long、long long等

因此可以得出，非类型模板参数一般是用来定义一个数组的大小的

2.2 实际例子：array容器

在C++11标准中，引入了一个容器array，它的底层使用了非类型模板参数，是一个真正意义上的泛型数组，这个是用来对标传统数组的。

#include <iostream>
#include <array>
using namespace std;int main()
{int arr[10] = { 0 }; //传统数组array<int, 10> _array; //array容器// 读arr[12];	  _array[12];// 写arr[12] = 0;	_array[12] = 10;return 0;
}

对比传统数组：

• array也并没有进行初始化。
• array新数组对于越界读、写检查更为严格。传统数组越界读写，不会发生报错；而array数组则会报错。

虽然对越界行为检查严格 ，但在实际开发中，很少使用array容器，因为它对标传统数组，连初始化都没有，而vector也是类似于数组的容器，在功能和实用性上可以全面碾压，并且 array使用的是栈区上的空间，会存在栈溢出问题，因此可以说array是一个鸡肋的容器。

三、模板特化

3.1 概念

模板特化顾名思义就是对模板(泛型思想)的特殊化处理 。模板特化中分为函数模板特化与类模板特化。

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。

比如：实现一个专门用来进行小于比较的函数模板

#include <iostream>
using namespace std;template<class T>
bool Less(T x, T y)
{return x < y;
}int main()
{int a = 1;int b = 2;cout << Less(a, b) << endl; // 可以比较，结果正确int* p1 = &a;int* p2 = &b;cout << Less(p1, p2) << endl; // 可以比较，结果错误return 0;
}

【输出结果】

上述示例中，p1指向的a显然小于p2指向的b，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址。

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

3.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参必须要和基础的模板函数的基础参数类型完全相同

#include <iostream>
#include <vector>
using namespace std;// 必须要先有一个基础的函数模板
template<class T>
bool Less(T x, T y)
{return x < y;
}// 对Less函数模板进行特化
template<> // 关键字template后面接一对空的尖括号<>
// 函数名后跟一对尖括号，尖括号中指定需要特化的类型
bool Less<int*>(int* x, int* y) // 函数形参必须要和基础的模板函数的基础参数类型完全相同
{return *x < *y;
}int main()
{int a = 1;int b = 2;cout << Less(a, b) << endl; // 可以比较，结果正确int* p1 = &a;int* p2 = &b;cout << Less(p1, p2) << endl; // 可以比较，结果错误return 0;
}

【输出结果】

不过对于函数模板特化来说，存在一个更加方便的东西：函数重载同样也能解决特殊需求

bool Less(int* x, int* y)
{return *x < *y;
}

3.3 类模板特化

模板特化主要用在类模板中，它可以在泛型思想之上解决大部分特殊问题，并且类模板特化还可以分为：全特化和偏特化

3.3.1 全特化

全特化指将原模板参数列表中所有的参数都确定化

注意：在进行全特化前

1. 需要存在最基本的泛型模板
2. 全特化模板中的模板参数可以不用写
3. 需要在类名之后，指明具体的参数类型，否则无法实例化出对象

// 原模板
template<class T1, class T2>
class Test
{
public:Test(const T1& t1, const T2& t2):_t1(t1), _t2(t2){cout << "Test(const T1& t1, const T2& t2)" << endl;}private:T1 _t1;T2 _t2;
};// 全特化后的模
// 将原模板参数列表中所有的参数都确定化
template<>
class Test<int, char>
{
public:Test(const int& t1, const char& t2):_t1(t1), _t2(t2){cout << "Test<int, char>" << endl;}private:int _t1;char _t2;
};int main()
{Test<int, int> T1(1, 2);Test<int, char> T2(20, 'c');return 0;
}

调用时会优先选择更为匹配的类模板

3.3.2 偏特化

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

• 部分特化

顾名思义只特化一部分模板参数

// 原模板
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;
};

• 参数更进一步的限制

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

借助偏特化解决指针无法正常比较问题

class Date
{
public:Date(int year = 1970, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}private:int _year;int _month;int _day;
};//原来的比较模板
template<class T>
class Less
{
public:bool operator()(T x, T y) const{return x < y;}
};//偏特化后的比较模板
template<class T>
class Less<T*>
{
public:bool operator()(T* x, T* y) const{return *x < *y;}
};int main()
{Date d1 = { 2018, 4, 10 };Date d2 = { 2023, 5, 10 };cout << "d1 < d2: " << Less<Date>()(d1, d2) << endl;cout << "&d1 < &d2: " << Less<Date*>()(&d1, &d2) << endl;int a = 1;int b = 2;cout << "&a < &b: " << Less<int*>()(&a, &b) << endl;return 0;
}

四、模板分离编译问题

4.1 什么是分离编译

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

4.2 模板的分离编译

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

【程序结果】

出现了链接错误！！！

【分析】

代码从文本变为可执行程序所需要的步骤：

1. 预处理：头文件展开、宏替换、条件编译、删除注释，生成纯净的C/C++代码
2. 编译：语法/词法/语义分析，错误检查无误后生成汇编代码。注意：头文件不参与编译，编译器对工程中的多个源文件是分离开并且单独编译的
3. 汇编：生成符号表，生成二进制指令
4. 链接：将符号表进行合并，并处理地址问题

当模板的声明和定义分离时，在realize.cpp中，由于是 泛型，编译器无法确定函数原型（实例化），因此无法生成函数，也就无法获得函数地址，在进行链接时，无法在符号表中找到目标地址进行跳转，导致链接错误

除了模板以外，还有一个很常见的连接错误，有函数声明，却没有定义

4.3 解决方法

1. 将声明和定义放到一个文件（推荐使用这种）

template<class T>
T add(const T x, const T y)
{return x + y;
}

2. 在函数定义时进行模板特化，编译时生成地址以进行链接（不推荐使用）

template<>
int add(const int x, const int y)
{return x + y;
}

五、小结

模板的优点：

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

模板的缺陷：

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