【C++ —— 模板】（初阶）

---

前言

此文为C++学习时笔记，如有误区和理解错误的地方还请麻烦指出哦

---

一、泛型编程

比如当我们要实现交换函数时:

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = a;
}
void Swap(char& a,char& b)
{
	char tmp = a;
	a = b;
	b = tmp;
}
void Swap(double& a, double& b)
{
	double tmp = a;
	a = b;
	a = tmp;
}

虽然使用重载函数可以实现，但是有些不好的地方

1.这种仅仅是因为参数类型不同就要重现写一个函数导致了代码复用率极低。当有新类型出现时用户就要手动添加。

2.代码的可维护性较低，一个出错可能导致全部出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

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

二、函数模板

1.函数模板格式

关键字：template

template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
我们用模板的方式对比以上代码。

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

注意：typename是关键字，可以使用class代替（不能用struct代替）

2.模板实现原理

模板是给编译器使用的，编译器用模板推演实例化生成对应的Swap函数。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

3.模板实例化

3.1 隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& a, const T& b)
{
	return a + ;b
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, a2);
	Add(d1, d2);
	return 0;
}

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

int main(void)
{
 	int a = 10;
 	double b = 20.0;
 
 	// 显式实例化
 	Add<int>(a, b);
 	return 0;
}

4.模板参数的匹配规则

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

数

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

// 通用加法函数
template<class T>
T Add(T a, T b)
{
 	return a + b;
}

void Test()
{
 	Add(1, 2); // 调用非模板Add函数，编译器不需要实例化
 	Add<int>(1, 2); // 调用编译器实例化的Add版本
}

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

// 专门处理int的加法函数
int Add(int a, int b)
{
 	return a + b;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 a, T2 b)
{
 	return a + b;
}
void Test()
{
 	Add(1, 2); // 与非函数模板类型，不需要函数模板实例化
 	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函
数
}

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

三、类模板

1 类模板的定义格式

template<class T1, class T2, ..., class Tn>
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;
}

注意：
类模板这个部分声明和定义分离时，不要分离成两个文件。分离成连个文件是会报错的。

2 模板实例化

注意：Vector类名，Vector<int>才是类型

Vector<int> s1;
Vector<double> s2;