【C++】模板初阶 | STL简介

本篇博客为大家带来C++模板初阶及STL简介，为后面的深入学习做一下知识的铺垫。

上篇博客：【C++】C/C++内存管理（new和delete详解）

---

1. 模板初阶

C++模板初阶主要介绍以下三个方面的知识：

1. 泛型编程
2. 函数编程
3. 类模板

1.1 泛型编程

泛型编程(Generic Programming) 指在多种数据类型上皆可操作。和面向对象编程不同，它并不要求额外的间接层来调用函数，而是使用完全一般化并可重复使用的算法，算法效率与针对某特定数据类型而设计的算法相同。

简单来说，泛型编程的目的是为了发明一种语言机制，能够帮助实现一个通用的标准容器库。通用的标准容器库是指能够实现这样一种功能：例如，用一个List类存放各种类型的对象。泛型与模板类似，指具有在多种数据类型上都可以操作的含义。

单纯看上面的定义解释可能比较难理解😰，下面以一个例子简单说明：
📌如何实现一个通用的交换函数？注意是通用哦，任何数据类型都能交换。

方法一：使用函数重载

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;
}

//......
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用函数重载虽然可以实现，但是这种方法也有一定的缺点：

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

既然只是交换的数据类型不同，而交换步骤基本一致，可能你会想到用一下typedef，但显然，typedef也不能解决这个问题，每次交换数据都得改动。

交换的模板都是同一个，那能否在每次交换时告诉编译器要交换的数据类型，让编译器根据不同的类型利用该模板来生成对应的交换函数代码呢？

由此，C++引入了模板的概念，通过给这个模板接收不同的类型，来获得具体类型的代码，这将大大减少代码冗余。

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

1.2 函数模板

1.2.1 函数模板的概念

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

1.2.2 函数模板格式

template<typename T1, typename T2, ……, typename Tn>
返回值类型 函数名(参数列表){ …… }
1
2

那么，我们可以根据这个知识点去编写一个通用的Swap函数模板了

方法二：使用函数模板

//泛型编程 -- 模板
// // 模板参数(模板类型)  --  类似函数参数(参数对象)
//typename后面类型名字T是自己随便取的，一般使用大写字母，或者单词首字母大写
//T 代表是一个模板类型（虚拟类型）
template<typename T>	
//template		//class和typename都可以使用
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}
1
2
3
4
5
6
7
8
9
10
11
12

在调用的时候，和普通函数传值一样，直接调用，没有其他任何区别。函数模板会根据传入的值，自动生成对应类型的函数代码。

注意：typelate是定义模板的关键字。而typename是用来定义模板参数类型的关键字，也可以使用class代替typename（切记：这里的class不能使用struct去代替）

1.2.3 函数模板的原理

实际上，函数模板只是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。其实模板就是将本来应该是我们做的重复的事情交给了编译器

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

1.2.4 函数模板的实例化

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

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

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);

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

	//1. 强制转化
	Add(a1, (int)d1);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

int main()
{
	int a = 10;
	double b = 20.0;
	
	// 显式实例化
	Add<int>(a, b);
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10

此时，该模板参数被直接指定实例化为int类型，后面接收的数据类型不匹配时，编译器会尝试进行隐式类型转换，如果转换失败，编译器会报错。

1.2.5 模板参数匹配原则

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

// 专门处理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版本
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

// 专门处理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(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

void Test()
{
	int a = 3;
	double = 7.0;

	Add(a, b);//error
	/*
	模板函数不支持自动类型转换，编译器也就无法判断是使用int实例化还是double实例化
	此时只能是用户强制类型转换，或者直接显式指定实例参数类型
	*/

	Add(a, (int)b);
	Add<int>(a, b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.3 类模板

1.3.1 类模板的定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
	// 类内成员定义
};
1
2
3
4
5

以Vector为例，简单定义如下：

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}

	// 使用析构函数演示：在类中声明，在类外定义。
	~Vector();

	void PushBack(const T& data)；

	void PopBack()；
	// ...

	size_t Size() 
	{
		return _size; 
	}

	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pData[pos];
	}

private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

1.3.2 类模板的实例化

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

// Vector类名，Vector才是类型
Vector<int> s1;
Vector<double> s2;
1
2
3

2. STL简介

这部分了解简单了解即可，后面会将SLT中常用的组件逐个详细介绍。这部分主要介绍以下内容：

1. 什么是STL
2. STL的版本
3. STL的六大组件
4. STL的重要性
5. 如何学习STL
6. STL缺陷

2.1 什么是STL

STL(standar template libaray - 标准模板库)：是C++标准库的重要组成部分，没错STL只是C++标准库的一个子集，它不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架

2.2 STL的版本

• 原始版本
  Alexander Stepanov、 Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。 HP 版本–所有STL实现版本的始祖。
• P.J.版本
  由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名比较怪异。
• RW版本
  由Rouge Wage 公司开发，继承自HP版本，被C+ + Builder 采用，不能公开或修改，可读性一般。
• SGI版本
  由Silicon Graphics Computer Systems，Inc公司开发，继承自HP版 本。被GCC(Linux)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。我们后面学习STL要阅读部分源代码，主要参考的就是这个版本。

2.4 STL的六大组件

2.5 STL的重要性

1. 笔试
   在OJ笔试中，会使用STL会舒服很多，向链表、队列、栈等操作，不需要像之前一样得先写一个链表、队列、栈出来，可以直接使用STL中的模板产生实例。

2. 面试
   

3. 工作
   网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。

2.6 如何学习STL

一位C++的dalao将STL的学习比喻为三个境界或层次：

• 第一境界：熟悉并正确使用STL
• 第二境界：了解泛型技术的内涵与STL的学理乃至实作
• 第三境界：扩充STL

即学习STL的三个境界：能用、明理、能扩展
在这里推荐一本比较好的书籍：侯捷老师的《STL源码剖析》

2.6 STL的缺陷

1. STL库的更新太慢了。上一版靠谱的是C++98，中间的C++03基本的一些修订，C++11出来已经相隔了十几年了，STL才进一步更新
2. STL现在都没有支持线程安全，并发环境下需要我们自己加锁，且锁的粒度是比较大的
3. STL极度的追求效率，导致内部比较复杂。比如类型萃取、迭代器萃取
4. STL的使用会有代码膨胀的问题，比如使用vector/vector/vector这样会生成多份代码，当然这是模板语法本身导致的

---

终于码完了😇😇，本篇博客主要都是过渡一些基础知识，了解了解即可。