模板初阶的学习

一：泛型模板

二：函数模板

三：类模板

1：泛型模板

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
以交换函数为列进行讲解：

void Swap(int& left, double & right)
{
	int temp = left;
	left = right;
	right = temp;
}
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;
}

我们发现这样的代码复用率不高，基本就是相同的代码（当然除类型不同），那有没有什么办法可以实现一个模具，让编译器自动根据参数类型进行指定函数的调用

2：函数模板

2.1 函数模板实例化

底层原理：编译器会根据当前调用函数实参的类型自动推到形参的类型（也就是说，使用模板函数会自动生成对应类型的函数，即函数的实列化）

当前这样写是不能编译过去的：在模板中，编译器不会自动进行类型的转换：实参a1对应double 类型，此时就会把 T自动视为double 类型，实参 a对应int 类型，此时编译器就发生了歧义，T到底是int 还是 double 类型

2.2实例化类型的转换

隐式实例化（强转）

显示实例化：在函数名后面 & 实参前面加上一个对应模板参数

2.3模板参数的匹配原则

思考以下问题：当调用Add（a,(int)a1)的时候编译器到底调用模板函数还是调用int Add（int&x,int &y)这个函数？？？

当我们调试的时候发现是调用模板函数，其实底层是调用现成的 int Add（int&x,int &y)这个函数，因为调用模板函数的最终目的还是生成对应的int Add（int&x,int &y)这个函数，现在有现成的函数，那编译器为什么要费这个劲呢

总结：

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

3：类模板

类模板的形式：

template < class T1 , class T2 , ..., class Tn >

class 类模板名

{

// 类内成员定义

};

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