模板的介绍

泛型编程

问题：目前需要实现一个能够对任何数据类型都能使用的交换函数，该怎么做？

void Swap(int& a, int& b)
{
	int t = a;
	a = b;
	b = t;
}

上述代码只能实现int类型的交换，如果想要实现double类型的交换，又需要再写一份代码。这是不是太麻烦了。

如果想要解决上述问题，我们就需要引入一个新的概念：泛型编程

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

通俗的理解泛型编程就像一个模子。比如雕版印刷，有了这样的模具，就可以印刷出很多的文章。

泛型编程也是这样的道理。那么为了解决问题，该怎么做呢？

这就又需要引入一个新的概念，那就是模板

模板

函数模板

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

函数模板格式：

template <typename T1, typename T2>

返回值类型 函数名（参数列表）{}

在了解这些知识之后就可以解决上述的问题了。

template <typename T>

void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

通过下面的例子可以测试模板的作用

int main()
{
	int a = 1, b = 2;
	Swap(a, b);

	cout << a << " " << b << endl;

	double c = 2.2, d = 3.4;
	Swap(c, d);
	
	cout << c << " " << d << endl;
	return 0;
}

注意：typename是用来定义函数模板关键字的，也可以用class,但是切记不能用struct.

函数模板的原理

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

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

函数模板的实例化

用不同类型的参数使用函数模板时，成为函数模板的实例化。

模板参数实例化分为：隐式实例化和显式实例化

template <typename T>

T Add(const T& x, const T& y)
{
	return x + y;
}

int main()
{
	int  a = 1 ;
	double b = 2.1;
	
	//以下为 ：根据实参传递的类型推演T的类型
	double c = 1.1, d = 2.2;
	cout << Add(c, d) << endl;

	cout << Add((double)a, b) << endl;   // 这条不会报错，因为a和b都是double类型
	cout << Add(a, b) << endl;     //报错，因为a是int类型，b是double类型

	//以下为显式实例化，用指定类型实例化
	cout << Add<int>(a, b) << endl;
	cout << Add<double>(c, d) << endl;
	return 0;
}

首先分析下面这句代码不能通过的原因

cout << Add(a, b) << endl;

因为a是int类,b是double类型，在传参的时候，通过实参a将T推演为int类型，通过实参b将T推演为double类型。模板参数列表只有一个T，编译器无法确定究竟是推演为int还是double,所以报错。

上述问题的解决办法有两个：
1. 用户自己来强制转换
2. 使用显式实例化

第一种方法：

cout << Add((double)a, b) << endl;

第二种方法：

	cout << Add<int>(a, b) << endl;
	cout << Add<double>(c, d) << endl;

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

模板参数的匹配原则

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

int Add(int a, int b)
{
	return a + b;
}

template <typename T>
T Add(T a, T b)
{
	return a + b;
}

int main()
{
	int a = 1, b = 2;
	cout << Add(a, b) << endl;

	double c = 2.2, d = 3.4;
	cout << Add(c, d) << endl;
	return 0;
}

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

根据上面的代码，验证结论。


3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

类模板

类模板的定义格式：

template <typename T>
class 类模板名
{
};

下面是一个样例：

template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		T* _array = new T[capacity];

		_capacity = capacity;
		_size = 0;
	}

	void push(const T& x)
	{
		//check(_size, _capacity)
		_array[_size] = x;
		_size++;
	}

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

stack不是真实的类，是一个模板类。和函数模板一样。
注意：类模板使用的时候只能进行实例化
样例：

int main()
{
	//如果使用类模板，就必须显式实例化，
	//因为无法像函数那样根据实参对形参的传递自动推导类型
	Stack<int> s1;  
	Stack<double> s2;
	Stack<char> s3;

	return 0;
}

类模板尽量不要声明和定义分离

template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 3);

	void push(const T& x)
	{
		//check(_size, _capacity)
		_array[_size] = x;
		_size++;
	}

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

上面的代码就是构造函数Stack声明和定义分离了。如果要在类外写构造函数，还像原来那样写，正确吗？

很明显，是错误的。
**因为类模板的作用域在类里面，出了类就不具备了。我们要在外面写，就需要重新再定义类模板。

也就是这样：

报错的内容意思是，”::前的的名称不是类名或者空间名。
可是Stack不就是类名吗，为什么会出错。

在没有模板的时候，类名和类型是相同的，都是Stack
在有模板的时候，类名是Stack，类型是Stack<T>

所以正确的写法是：

template <typename T>
Stack<T>::Stack(size_t capacity = 3)
{
	T* _array = new T[capacity];

	_capacity = capacity;
	_size = 0;
}

类模板的实例化

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

int main()
{
	//如果使用类模板，就必须显式实例化，
	//因为无法像函数那样根据实参对形参的传递自动推导类型
	Stack<int> s1;  
	Stack<double> s2;
	Stack<char> s3;

	return 0;
}