C++模板

模板

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。
模板是创建泛型类或函数的蓝图或公式

泛型编程

如何去实现一个通用交换函数
利用函数重载虽然可以实现 如下

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
void Swap(double& x, double& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
void Swap(double& x, double& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

但是 用函数重载实现几个不好的地方

• 重载的函数仅仅只是类型不同 代码复用率太低 只要有新的类型出现 就需要自己实现对应类型的函数
• 代码可维护性太差 一个出错可能所有的重载全部出错

在C++中 引入了模板这个概念 即存在一个模具 通过这个模具填充不同的材料(类型) 来获得不同材料的铸件 (生成具体类型的代码)
就好像月饼一样 同一个造型的月饼可以有多种不同的口味

泛型编程: 编写与类型无关的通用代码 是代码复用的一种手段

C++中模板包括函数模板和类模板

函数模板

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

函数模板格式

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

比如

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y; 
	y = tmp;
}
1
2
3
4
5
6
7

template是定义模板的关键字
typename 是定义模板参数的关键字 也可以使用class(不能用struct代替class)

函数模板的原理

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

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

比如用double类型使用函数模板时 编译器通过对实参类型的推演 将T确定为double类型 然后生成一份专门处理double类型的代码

通过汇编也可以看出 他们调用的并不是同一个函数

函数模板的实例化

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

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

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

	Add(a1, d1);//error 编译错误 无法确定到底将T确定为int 或者double而报错
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

解决上面的问题 可以使用强制类型转换进行解决

Add(a1,(int)d1);
1

也可以使用显示实例化

• 显示实例化 在函数名后面加<> 来指定模板参数的实际类型

template <class T>
T Add(const T& x, const T& y)
{
	return x + y;
}
int main()
{
	int a1 = 10;
	int a2 = 20;
	double d1 = 10.0;
	double d2 = 20.0;
	Add<int>(a1, d1);
	Add<double>(a1, d1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

如果类型不匹配 编译器会尝试隐式类型转换 如果无法转换成功 编译器将会报错
**[注意]：类型转换会产生临时变量 临时变量具有常性 所以类型转换时模板参数一定时const类型**

函数模板参数的匹配原则

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

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

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

//通用加法函数
template <class T1 ,class T2>
T1 Add(T1 x,  T2 y)
{
	return x + y;
}
int main()
{
	Add(10, 20); //与非模板函数匹配 不需要函数模板实例化
	Add(1, 2.0); //模板函数可以生成更加匹配的版本 编译器根据实参生成更加匹配的Add函数
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

类模板

类模板定义格式

template
class 类模板名
{
//...
};
比如实现一个栈

//类模板
template <class T>
class Stack
{
public:
	Stack(int n = 2)
		:_a(new T[n])
		,_top(0)
		,_capacity(0)
	{
	}
	~Stack();//类外定义
private:
	T* _a;
	int _top;
	int _capacity;
};

//类模板中函数放在类外面进行定义 需要加模板参数列表
template <class T>
Stack<T>::~Stack()
{
	delete[] _a;
	_a = nullptr;
	_top = _capacity = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

类模板的实例化

类模板实例化与函数模板实例化不同 类模板实例化需要在类模板名字后面加<> (即显示实例化)然后将实例化的类型放在<>中即可 类模板名字不是真正的类 而实例化的结果才是真正的类
实例化栈

Stack<int> s1;
Stack<double> s2;
1
2