C++之模板初阶：甩锅编译器

前言

hello，大家好，今天博主来继续更新C++系列的文章，今天我们来分享的是模板，欢迎大家继续支持。

1.泛型编程

假如我们需要实现两个数的交换，但因为这两个数字有可能是int型，也有可能是double型，还有可能是char型，所以，为了每一种类型的数字都可以交换，我们就要针对每一种类型都写一个函数，这样做很麻烦。在C++中，是支持重载技术的，这样我们可以把每一种类型的交换函数都命名为Swap，但是，当有新的类型出现时，依旧需要增加新的函数，使用起来依旧不方便。
下面的代码展现了针对不同类型的交换函数。

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

既然如此麻烦，我们有没有办法能够使这种情况更简洁一些呢？能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？这样我们就可以从写许多函数中解放出来。
于是我们引入了泛型编程，即编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
模板分为函数模板和类模板，接下来我们就来介绍他们。

2.函数模板

2.1函数模板概念

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

2.2 函数模板格式

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

template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}

typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

2.3 利用模板来实现两个数的交换

#include
using namespace std;

template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a = 1;
	int b = 2;
	Swap(a, b);
	cout << "a:" << a << "," << "b:" << b << endl;
	double c = 3;
	double d = 4;
	Swap(c, d);
	cout << "c:" << c << "," << "d:" << d << endl;
	return 0;
}

我们看，利用模板是不是方便许多呢？
那么你心中是否有一个疑问，当我们在使用模板的时候，我们调用的是同一个函数吗？我们来看一下汇编代码：

我们发现两次调用的函数地址是不同的，这说明他们不是一个函数。

2.3 函数模板原理

既然我们知道，即使有了模板，编译器在处理的时候，依旧是按照不同函数来处理的，那么编译器处理的原理又是什么呢？

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

也就是说，所谓的函数模板，就是把本来需要我们来写的代码交给编译器来写。所以，模板不只是Ctrl+V，而是根据实际情况，处理成不同的代码。这其实就是一种甩锅啊，本来应该我们做的事情，由于我们的“懒惰”，我们交给了编译器去做，然后编译器默默承担了所有。

2.4 函数模板的实例化

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

所谓的模板实例化就是将模板运用到具体情境中，将一个抽象的化为具体的。交换两个数很模糊，交换两个int型对数就清晰很多。
函数模板的实例化分为隐式实例化和显式实例化，接下来我们就来介绍他们。

2.4.1 隐式实例化

让编译器根据实参推演模板参数的实际类型

#include
using namespace std;

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);
	return 0;
}

但是，如果我们将上面的代码添加一行a1+d2的代码，编译器就会报错。

报错的原因很简单，因为a1和d2的类型不同，编译器懵了，不知道该咋整了。于是这个时候，我们就需要明确地告诉编译器按照上面类型来相加，于是我们就需要显式实例化。

2.4.2 显式实例化

在显式实例化中，我们需要用<>来告诉编译器，我们期待它处理成什么类型的数据。我们将上面的代码用<>来点缀一下。

#include
using namespace std;

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<int>(a1, d2);
	return 0;
}

2.5 模板类型匹配原则（择优）

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

#include
using namespace std;
// 专门处理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 main()
{
	Test();
}

我们看，在这段代码中，既有普通定义的Add函数，又有模板的Add函数，二者是可以同名的。那么我们不禁要问，在不同情况下，编译器会调用普通函数还是模板呢？
我们看Add（1,2）这个调用语句就是普通调用语句，编译器会直接调用Add函数，对于编译器来说，有现成的函数不去调用，干嘛要在去自己才该生成哪一种类型的函数啊？
而对于Add(1,2)。语句已经告诉编译器显式实例化了，证明是要模板的，所以这个调用的是模板函数。

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

// 专门处理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函数
}

在这个例子中，Add（1,2.0）是调用模板的，因为模板可以根据实参生成匹配的版本，而普通的Add函数却不可以满足double型，所以编译器会选择模板。

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
如果模板支持自动类型转换的话，还要<>干什么？

3. 类模板

3.1 类模板定义的格式

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

3.2 类模板的一个应用实例

// 动态顺序表
// 注意：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;
}

3.3 类模板实例化

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

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

4.模板不支持分离编译

模板不支持分离编译，也就是说模板不支持声明在.h,定义在.cpp。
建议定义在一个文件里。

5.后记

好的，今天我们关于模板的知识就先介绍到这里，希望对大家有所帮助。我们在文章中已经介绍过，模板的原理其实就是甩锅。我想起了小时候读过的一个很有趣的甩锅的故事，北宋书画家米芾，在一个地方做县令，有一年闹起了蝗灾，米芾带领百姓消灭了蝗灾，不料隔壁县也爆发了蝗灾，隔壁县令苦恼不已，于是就想甩锅给米芾，说自己县里的蝗虫都是米芾的县赶去的，米芾收到甩锅信看完后当然不答应，于是回了他一首打油诗，很有趣，分享如下：

蝗虫本是天灾，岂由小官遣派？

倘说鄙人赶去，速请阁下押来。