让你认识C++中的模板

一. 泛型编程

1、定义

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

首先我们看这样一个代码：

#include
void Swap(int& a, int& b) {
	int tmp = a;
	a = b;
	b = tmp;
}
void Swap(float& a, float& b) {
	float tmp = a;
	a = b;
	b = tmp;
}
void Swap(char& a, char& b) {
	char tmp = a;
	a = b;
	b = tmp;
}
int main() {
	int a = 1;
	int b = 2;
	Swap(a, b);
	cout << a << b << endl;
	float c = 3.3;
	float d = 2.2;
	Swap(c, d);
	cout << c << d << endl;
	char e = 'c';
	char f = 'd';
	Swap(e, f);
	cout << e << f << endl;
	return 0;
}

这个代码中的三个函数是不是，重复的地方非常多，除了参数的类型不同之外其他的地方几乎都是相同的。那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
我们可以用函数模板来解决这个问题。

二、函数模板

1、定义

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

2、格式

#include
using namespace std;
template<typename T>
void Swap(T& a, T& b) {
	T tmp = a;
	a = b;
	b = tmp;
}
int main() {
	int a = 1;
	int b = 2;
	Swap(a, b);
	cout << a << b << endl;
	float c = 3.3;
	float d = 2.2;
	Swap(c, d);
	cout << c << d << endl;
	char e = 'c';
	char f = 'd';
	Swap(e, f);
	cout << e << f << endl;
	return 0;
}
}

我们可以用这一个函数模板来代替上面代码的三个函数包括其他类型。

其中template是用来声明模板的关键字，typename是用来定义模板参数关键字，也可以使用class，T就是类型名称，可以自己随意命名。

3、函数模板的实例化

如果我们遇到下面的代码我们还可以运行么？

#include
using namespace std;
template<typename T>
T Add(T a, T b) {
	T c = 0;
	c = a + b;
	return c;
}
int main() {
	int c = 1;
	float d = 2.2;
	cout << Add(c, d) << endl;
	return 0;
}

这时他就会报错，因为两个参数的类型不同，就推导不出来T的类型。那么我们怎么解决这个问题，有以下两种方法：

（1）、强制转化

#include
using namespace std;
template<typename T>
T Add(T a, T b) {
	T c = 0;
	c = a + b;
	return c;
}
int main() {
	int c = 1;
	float d = 2.2;
	cout << Add(c,(int)d) << endl;//强制转化
	return 0;
}

将float类型转化为int类型，或者也可以将int类型转化为float类型。

（2）、显式实例化

#include
using namespace std;
template<typename T>
T Add(T a, T b) {
	T c = 0;
	c = a + b;
	return c;
}
int main() {
	int c = 1;
	float d = 2.2;
	cout << Add<int>(c,d) << endl;
	return 0;
}

上面是将参数类型全部显示实例化转化为int类型，当然也可以转化为float类型。<>中间是模板参数的实际类型。

三、类模板

1、 类模板的定义格式

template
class 类模板名
{
// 类内成员定义
};

2、实例

template<class T>
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = new T[capacity];
		_top = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	T* _a;
	int  _top;
	int  _capacity;
};

这里我们在每一次定于栈的时候如果我们想修改”_a“的类型是不是每一次都得对"_a"的类型进行修改。那么我们用了类模板是不是不用再对”_a“的类型再进行修改了，编译器直接就会帮助我们进行推导。

3、 类模板的实例化

函数模板可以进行显示实例化，类模板也可以进行显示实例化。

int main{
	Stack<int> st1;  // int
	Stack<double> st2;  // double
	return 0;
	}

这样我们就可以定义不同类型的对象了。