1 泛型编程

编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。其中模板包括函数模板和类模板。

2 函数模板

2.1 函数模板概念

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

2.2 函数模板格式

typename：定义模板参数关键字，也可使用class

template<typename T1[,typename T2,typename T3]>
返回值类型 函数名(参数列表){}

或

template<class T1[,class T2,class T3]>
返回值类型 函数名(参数列表){}

2.3 函数模板的实例化

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

2.3.1 隐式实例化

2.3.1.1 定义

编译器通过实参的数据类型推演模板参数的实际类型

2.3.1.2 代码演示

// 模板实现两数交换
template<class T>
void Swap(T& a, T& b) {
	T t = a;
	a = b;
	b = t;
}

int main() {
	// 隐式实例化
	int a1 = 10, a2 = 20;
	cout << "a1 = " << a1 << " a2 = " << a2 << endl;
	// 此时模板参数为int
	Swap(a1, a2);
	cout << "swap" << endl;
	cout << "a1 = " << a1 << " a2 = " << a2 << endl;
	cout<<endl;
	
	double a3 = 10.1, a4 = 20.1;
	cout << "a3 = " << a3 << " a4 = " << a4 << endl;
	// 此时模板参数为double
	Swap(a3, a4);
	cout << "swap" << endl;
	cout << "a3 = " << a3 << " a4 = " << a4 << endl;
	return 0;
}

2.3.1.3 运行结果

2.3.1.4 缺点

当两参数数据类型不一致时，编译器无法推演出模板的数据类型

可通过类型强转或显式实例化解决。
类型强转：Swap(a1,(int)a3);

2.3.2 显式实例化

2.3.2.1 格式

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

2.3.2.2 代码演示

// 实现两数相加模板
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main(){
	int c1 = 10, c2 = 20;
	double d1 = 10.1, d2 = 20.2;
	cout << Add(c1, c2) << endl;
	cout << Add(d1, d2) << endl;
	// 参数类型强转
	cout << Add((double)c1, d2) << endl;

	// 显示实例化
	// 指定为int型
	cout << Add<int>(c1, d2) << endl;
	// 指定为double型
	cout << Add<double>(c1, d2) << endl;
	return 0;
}

2.3.2.3 运行结果

经过显式实例化后int+double型也可以算出和

2.4 模板参数的匹配原则

2.4.1

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

2.4.2

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

2.4.3

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

3 类模板

3.1 类模板格式

template<class T>
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 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;
}
};

3.2 类模板实例化

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

// vector<int>：类型名
Vector<int> v1;
Vector<double> v2;