总述

本篇文章将带大家简单的了解一下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;
}
//。。。。

运用c++函数重载的特性虽然可以实现，但是有以下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新的类型出现，就需要用户自己增加对应的函数
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
作为关键字，但为了防止和类混淆，后面又新增了关键字typename），也可以使用class， 但不能用struct代替class！

函数模板的原理

想想制造机器时的图纸，根据图纸再加上一些自己的想法生产出一件件机器，函数模板是不是就很想这个呢？

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

template<typename T>
void swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 10, b = 20;
	swap(a, b);

	double c = 1.1, d = 2.2;
	swap(c, d);
	char ch1 = a, char ch2 = b;
	swap(ch1, ch2);
	
	//下面这句代码能够编译成功吗？
	//swap(c, a);
	//???
	return 0;
}

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

但是，大家也发现了上面那段代码的最后面提出了一个问题，如果传入的实参是两个不一样的类型会怎么样呢？能编译通过吗？

这里先给出答案，**不能！**至于为何不能，将在下一部分进行讲解。

函数模板的实例化

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

隐式示例化

j简单来说就是让编译器根据实参推演模板参数的实际类型，也就时上面的那种用法。

这里来讲讲为什么上一段代码的最后一句swap(c, a);没办法编译通过。

当编译器在看到该实例化时，需要推演其参数类型，实参c将T推演成double，实参a将T推演成int，但模板参数列表中只有一个T，编译器无法确定到底要使用int还是double类型，所以会报错！

这就好比家里有爸爸又有妈妈，但是你应该听爸爸的话还是妈妈的话呢？(●’◡’●)

有人可能会说：为什么这里不能用自动类型转换呢？
答案其实很简单：编译器不想**背黑锅！**因为自动类型转换可能导致程序的结果不是程序员想要的！

此时这里就有三种方法处理，这里先说前两种种方法：
多加一个类型推演：
看下面一个代码：

template <typename T1, typename T2>
void swap(T1& a, T2& b)
{
 //...
}

通过选择两个类型参数，就能够接受两个不同类型的参数，然后在函数内部按照自己想要的方式编写即可。

用户自己来强制类型转换

例如可以这么使用函数,swap(a,(int)c);
这样就可以让两个变量的类型强制相同，也不会报错了！

当然也可以使用第三种方法：显式实例化

显式实例化

在函数名后的<>中指定模板参数的实际类型

例如如下代码：

int main()
{
	int a = 10;
	double b = 20.1;
	swap<int>(a,b);
	return 0;

**注意：**如果类型不匹配，编译器会进行隐式类型转换，如果无法转换成功编译器就会报错。

模板参数的匹配规则

最后再来讲一下关于函数模板和非模板函数的一些细节

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

//专门处理int的加法函数
int Add(int left, int right)
{
	return left+right;
}

template <typename T1, typename T2>
void Add(T1 left, T2 right)
{
	return left+right;
}

int main()
{
	Add(1,2);  //与非模板函数蚕食完全相同，调用非模板函数
	Add<int, int>（1，2） //调用函数模板生成的实例化函数
	Add(1,2.0);  //将调用非模板函数还是实例化呢？
}

对于最后一个函数调用，将使用非模板函数还是函数模板的实例化呢？这里就要引出模板函数的第二个细节。

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

对于最后一个函数调用，显然生成的实例化Add<int,double>()能更好的匹配函数调用（虽然对于非模板函数通过隐式类型转化也能调用）

类模板

为什么会有类模板呢？其实是为了以后的STL容器做铺垫，例如想要建立一个能够存储多种类型的顺序表，就需要使用类模板。

类模板的使用格式：

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

来看一个简单模拟的能够存储多种类型的顺序表：

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

类模板的实例化

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

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

---

以上就是关于模板的简单了解了，如果大家有不懂的或者发现博主写的有错误的，欢迎大家提出！当然，这篇博客只是带大家简单的了解模板，关于模板的知识还有很多，博主将会在以后的博客继续完善！