作者：小树苗渴望变成参天大树
作者宣言：认真写好每一篇博客
作者gitee:gitee
作者专栏：C语言,数据结构初阶,Linux,C++

如 果 你 喜 欢 作 者 的 文 章 ，就 给 作 者 点 点 关 注 吧！

---

前言

今天我们来学C++当中的模板，可以说，有了模板我们的C++才开始比C语言好用很多，才开始慢慢体会到C++的优点之处，今天我先带大家入门，基本语法先学会，，这样才能更好就如STL的学习（后面回中带你介绍的），后面我们再将模板的进阶，话不多说，我们开始进入正文

---

`

一、为什么要模板？

在古代我们的活字印刷术，就是有很多模子，按照模子印刷出来字，在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;
}

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

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

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

二、怎么使用模板

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板有两种：

我们先来介绍函数模板

2.1函数模板

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

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

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

这就是一个简单的函数模板，那使用的时候是调用函数模板吗？？，我们来看看汇编：

我们看到调用的并不是函数模板，实际上模板只是一个模子，再调用函数的时候，编译器会根据模板来自动生成和调用函数类型匹配的函数，可以这么理解吧，原来我们自己做的事，现在交给编译器去做了，这上面事显示实例化，一会再介绍

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

对于函数模板大家应该有了一定的认识，接下来我讲讲解其他细节。

如果交换不同类型的两个值，上面那种写法就不行，：

这个时候就会出现类型不明确，同一个模子T1，不能同时接收int,又接收double,这个时候又三种办法解决这个问题

一、 定义多个模子

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

这样就可以各自匹配传进来的参数了,根据实际规则来定义模子个数。

二、 隐式实例化：让编译器根据实参推演模板参数的实际类型
这是让用户自己进行强制类型的转换

Swap(a,(int)c);
Swap((double)a,c);

但是这种方法用的很少，第三种方法以后用的比较多

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

Swap<int>(a,c)
Swap<double>(a,c);

这两种写法为什么有错误呢，因为只有一个模子，我们显示实例化之后，对于第一个，就会听int的，这必然有一个存在类型转换，发现类型转换就会创建临时变量，来传给参数，而临时变量具有常性，我们上面写的模板没有加const，就会出现错误。

这样就可以了，为什么第二种方法也进行了强转，但没有事情呢？？原因是，再传进去之前就已经转好了，而第三种是传进去之后才开始进行类型转换的。

---

再函数模板的时候，显示实例化用的不多，再介绍类模板的时候用的多，但是有一种场景用的多
在没有传参的时候，模子没有匹配的类型，那么返回的类型就没有，所以需要显示实例化，告诉模子要变成什么类型进行返回。

模板参数的匹配原则

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版本
}

第一个只会调用非模板函数，因为会先匹配合适的非模板函数。

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函数
}

对于函数模板，我就先讲到这里，还有细节我们在进阶里面再具体介绍，接下来讲类模板

2.2类模板

格式：

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

类模板是我们以后使用最多，为什么要有类模板呢，我们把老朋友请出来

typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
 {
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
 {
perror("malloc申请空间失败!!!");
return;
 }
_capacity = capacity;
_size = 0;
 }
void Push(DataType data)
 {
// CheckCapacity();
_array[_size] = data;
_size++;
 }
// 其他方法...
~Stack()
 {
if (_array)
 {
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
比特就业课
 }
 }
private:
DataType* _array;
int _capacity;
int _size;
};

我们有没有可能不同的栈存放不同数据类型的数据？？，答案肯定是肯定有可能的

Stack<int> s;
Stack<double> s;

按照原来，我们可能就需要把这个代码复制一份，然后在修改一下类型就行，但是类模板就是来解决这样繁琐的事，我们来看看具体怎么操作的

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

大家应该可以看到怎么实现了吧，这个也只是类的模板，不是泪，和函数模板相同的道理

类的模子也不止一个，根据实际情况来定义，但是类必须要显示实例化，才能告诉模子需要什么类型。

类模板对于声明和定义和之前有一些的不同

Vector::~Vector()

按照之前的想法，在外面定义必须要使用类名指定

普通类：类型和类型是一样的。
类模板：类型和类名不一样的。

我们在定义变量的时候，都是类型加变量，在类外面定义的函数，也是通过类型指定的，原来类名和类型相同，大家就以为是以类名指定，其实是类型指定的。正确写法为：

template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0; }

重点：我们定义的模子只在下一行的代码段内有效，例如：

template <class T>
void Vector<T>::PushBack(const T& data){}//1


void Vector<T>::PopBack(){}//2

我们定义的T只在1中有效，在二中就会报错，在前面必要要加定义才可以，例如：

template <class T>
void Vector<T>::PushBack(const T& data){}//1

template <class T>
void Vector<T>::PopBack(){}//2

这个一定要注意好。

对于类模板在初阶，就讲这么多，差不多够我们进入STL的学习，其他的细节我们在进阶在具体介绍，初阶讲的模板不是很难，把一些简单的细节给掌握好就行了，接下来我先String类，也是一个很关键的知识点，内容有点多，我们分多篇博客进行讲解，今天的知识就先分享到这里了，我们下篇再见。