一、泛型编程

    泛型编程就是编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础，可能不太好理解，这里我给大家举一个现实生活中的例子，我们想做很多个草莓形状的橡皮泥玩具，并且这些草莓玩具颜色不同，效果如下：

    问题来了，我们该怎么解决这个问题呢？难道拿出不同颜色的橡皮泥开始一个一个捏吗？但是这样的话效率是不是很低呢？所以我们会这样想，既然这些草莓玩具的形状相同，只是颜色不同，我们是不是可以做一个草莓模具，当我们想做一个草莓玩具的时候，就可以将对应颜色的橡皮泥填充模具，最终得到这个草莓，如下：

    这样我们有了模具以后，只需要使用对应颜色的橡皮泥就可以批量制作草莓了，非常高效，这就属于泛型编程的思维，大家可能还是感受不到，我们再举一个有关编程的例子，也就是使用C语言实现两个变量的交换，如下：

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(double& x, double& y)
{
	double tmp = x;
	x = y;
	y = tmp;
}

void Swap(char& x, char& y)
{
	char tmp = x;
	x = y;
	y = tmp;
}
//其它类型就不再一一列举了

    我们可以发现，如果是C语言来写这种交换函数，每一种类型我们都要把这个函数套一遍，但是其实这些函数除了类型不同基本上没有区别，如果每种类型都写一次实在太麻烦了，所以在C++中引入了模板的概念，就类似于做草莓玩具的模具，通过模具可以制作非常多的草莓玩具，通过模板可以快速生成多个函数，接下来我们正式开始学习模板

二、函数模板

1. 函数模板的概念和格式

    函数模板代表了一个函数家族，也就是该函数模板与类型无关，当我们使用一个类型的函数，编译器会根据这个类型产生函数的特定类型版本，可能有点不好懂，看到后面大家就明白了，我们先来看看函数模板的语法格式：

//这里的typename可以替换为class，用于声明类型T1到Tn都是类型
template<typename T1, typename T2,......,typename Tn>
//这里正常写函数的实现即可，只是把类型换成上面的T1到Tn
//注意上面的类型名可以自己取

    当我们把函数中的类型换成自己定义的类型名后，只要我们在函数中使用自己定义的类型名，比如T1，那么编译器在编译时就会按需给我们生成对应类型的函数，我们直接来举一个例子，如下：

#include <iostream>
using namespace std;

//这里也可以使用template<class T>，用于声明类型，可以有多个类型
template<typename T>
void Swap(T& x, T& y)//将类型替换成T
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 1;
	int b = 2;
	cout << "交换前：a:" << a << "b:" << b << endl;
	//编译器根据需求会自动按照模板生成一个int类型的Swap
	Swap(a, b);
	cout << "交换前：a:" << a << "b:" << b << endl;
	double c = 1.2;
	double d = 23.1;
	cout << "交换前：c:" << c << "d:" << d << endl;
	//编译器根据需求会自动按照模板生成一个double类型的Swap
	Swap(c, d);
	cout << "交换前：c:" << c << "d:" << d << endl;
	return 0;
}

    在上面的例子中，我们使用模板写了一个Swap函数，属于函数模板，编译器按需实例化出一个又一个的Swap函数，比如我们传int类型的参数，编译器就会生成int类型的Swap函数，就跟我们上面讲的草莓玩具的例子一样，根据模具就能很轻松的制作出来草莓玩具

    编译器也可以根据函数模板很轻松地实例化出不同的类型的函数，我们来看看上面举例的代码的运行结果，看看是否能做到我说的效果：

    可以看到代码没有问题，这里我们简单了解了一下函数模板的格式并且举了一些例子，接下来我们详细讲讲函数模板的原理和实例化

2. 函数模板的原理

    函数模板的原理其实我们都已经说过了，跟草莓模具的描述差不多，但是我们还是简单总结一下，函数模板就像是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器，如下图：

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

3. 函数模板的实例化

    用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化，接下来我们一个一个介绍：

隐式实例化

    隐式实例化就是不需要程序员指定相应的类型，让编译器自己去根据实参的类型实例化出对应的函数，比如之前我们举的Swap函数的例子，我们使用的就是隐式实例化，因为我们没有指定函数内部的类型，是靠编译器根据实参实例化出的

    隐式实例化有时候非常方便，因为不需要我们关心类型，但是隐式实例化也有它的不足，因为在一定的情况下编译器也不知道到底怎么实例化出对应的函数，我们来看以下的例子：

#include <iostream>
using namespace std;

template<class T>//也可以用typename
T Add(constt T& x, const T& y)
{
    return x + y;
}

int main()
{
    int a = 1;
    double b = 2.2;
    Add(a, b);
    return 0;
}

    在上面的例子中，我们设计Add的函数模板时只给了一个类型，但是传参数时却传了两种类型，编译器此时就不知道到底该用哪种类型去实例化，所以就会报错，解决办法有三种，第一种方法就是对任意一个参数进行强制类型转换，让参数类型强行一致，第二种方法就是增加模板参数，第三种方法就是显式实例化

    我们先讲一下前两种方法，最后一种方法我们在显式实例化部分讲解，如下：

//方法一：将某个变量进行强转
Add(a, (int)b);

//方法二：增加模板参数
template<class T1, class T2>//也可以用typename
T1 Add(constt T1& x, const T2& y)
{
    return x + y;
}

    上面两种方法都能解决报错，但是给我们的感觉就是麻烦，因为如果一个函数有很多参数，就有可能强转多次，并且修改模板参数也很麻烦，最后还是只能返回一种类型，跟强转效果差不多但是更麻烦，那么有没有什么更好的方法呢？其实就是第三种方法，显式实例化，我们一起来学习

显式实例化

    显式实例化就是在函数后面加一对尖括号，里面写上类型，这样就说明你已经确定要将这个函数实例化为某种类型，不用编译器去推导，过程中如果出现其它类型，那么编译器就会将它强转为尖括号中的类型，如果强转不了就会报错，如下：

//方法三：显式实例化
Add<int>(a, b);//b会被强转为整形

    一般来说显式实例化用在类模板实例化中，但是其实函数模板也可以使用，就是用来应对上面的这种场景，那么函数模板我们就了解到这里，后面我们还有进阶，不过要等后面讲完STL后我们再学习，接下来我们就来学习类模板

三、类模板

    有了函数模板的基础我们学习类模板就轻松很多了，因为类模板和函数模板类似，甚至比函数模板更简单，我们先来看看类模板的格式，如下：

//这里可以是class也可以是typename
template<class T1, class T2, ..., class Tn>
class 类模板名
{
	// 类内成员定义以及成员函数的实现
};

    可以看出类模板的定义和函数模板的定义都是非常相似的，是在类的最前面定义好类型供我们在实现中使用，接下来我们就来举一个例子，看看类模板是否实用，如下：

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	
private:
	T* _arr;
	size_t _capacity;
	size_t _size;
};

    这里我们利用类模板简单写了一个栈，跟之前唯一不同的是其中数据类型被替换成我们定义的类型T了，这样写的好处是可以根据要求实例化出不同类型的栈，比typedef一个类型好用多了，因为类模板可以同时使用多个类型的栈，但是typedef做不到，它一次只能替换一个类型，使用类模板是非常重要的

    除此之外类模板的实例化也很重要，它不能由编译器来自动识别，也就是不能隐式实例化， 只能显式实例化，这是为什么呢？我们来看看一个类对象的实例化语句，如下：

Stack st;

    不知道大家发现没有，类对象实例化时是看不出来类型的，函数模板可以通过实参推导，可类模板做不到，因为没有参数，所以类模板只能采用显式实例化的方式实例化对象，如下：

//让类模板实例化出来一个int类型的栈
Stack<int> st1;
//让类模板实例化出来一个double类型的栈
Stack<double> st1;

    那么今天模板初阶的内容就讲到这里，如果有问题欢迎在评论区提出，后面我们就可以开始STL的学习了，敬请期待吧！

    bye~