函数模板

跳动的bit
119 阅读5分钟

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第15天，点击查看活动详情。

💦 函数模板的原理

那么如何解决上面的问题呢？大家都知道，瓦特改良蒸汽机，人类开始了工业革命，解放了生产力。机器生产淘汰掉了很多手工产品。本质是什么，重复的工作交给了机器去完成。有人给出了论调：懒人创造世界。

这里的懒人指的是行动上变懒了 (只是不想做重复的事情)，思想上并没有滑坡。 在这里插入图片描述 马云：世界是懒人创造的 在这里插入图片描述 如上代码一个函数能完成这里几种函数的功能吗 ❓

显然是不能的

它们在调用的时候都要执行 Swap 函数，如果它是一段指令，它是没法完成的。经调试每次调用都往 Swap 函数里走，实际上 VS 的编译器为了方便调试所以在调试器上做了手脚，所以实际还是调用了对应的函数，这个过程叫做模板的实例化。

可以看到汇编代码，它们依然去调用对应的函数： 在这里插入图片描述

编译器是怎么帮我们完成的呢 ❓ 在这里插入图片描述 函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器，可以看到模板就是让你写的时候省劲了，但实际调用还是无差别。

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

对于类型的推演，跟 auto 有关系吗 ？？？

并没有关系。这里的场景是不一样的：这里是针对调用一个函数或是下面的类时，根据用的角度去指定参数，然后把参数替换生成对应的代码；auto 是不能做参数和返回值的，它是在定义变量的时候用 —— auto e = 3.14; 它是根据 3.14 的类型去推演 e 的类型。可以看到虽然它们使用场景不一样，但是原理还是很相似的。

库里的 swap ❓

其实 C++ 库里有给 swap 的实现 (也就是说不需要自己写了)： 在这里插入图片描述

int main()
{
	int a = 3, b = 5;
	swap(3, 5);
	
	int i(1);
	int(10);//匿名

	return 0;
}

📝说明

到了这里可以认为内置类型是有构造函数的，当然这里只是用法上的一个构造 —— 初始化

比如后面要学的 STL ，不排除 T 就是 int ： 在这里插入图片描述

💦 函数模板的实例化

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

  1. 隐式实例化：让编译器根据实参推演模板参数的实际类型
  2. 显式实例化：在函数名后的 <> 中指定模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	
	cout << Add(a1, a2) << endl;//ok
	cout << Add(d1, d2) << endl;//ok

	//cout << Add(a1, d2) << endl;//???
	//1、
	cout << Add(a1, (int)d2) << endl;
	cout << Add((double)a1, d2) << endl;
	//2、上面是实参去推演形参的类型，这里不需要推演，显示实例化指定T的类型
	cout << Add<int>(a1, d2) << endl;
	cout << Add<double>(a1, d2) << endl;

	return 0;
}

📝说明

Add(a1, d2)：该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型，通过实参 a1 将 T 推演为 int，通过实参 d1 将 T 推演为 double，但模板参数列表中只有一个 T，所以编译器无法确定此处到底该将 T 确定为 int 还是 double 而报错。

怎么解决呢 ❓ 在这里插入图片描述

假设我们不用模板，那么编译器就不会推演了，而这里能从 double 到 int 的原因是它们是相近类型，其中发生了隐式类型转换。

这里有两种处理方式：

  • 用户自己强转
  • 使用显式实例化

显式实例化的场景 ❓

class A
{
public:
	 A(int x)
	 {}
};
template<class T>
T func(int x)
{
	T a(x);
	return a;
}
int main()
{
	//func(1);//err

	func<A>(1);
	func<int>(1);
	return 0;
}

📝说明

有些函数模板里面参数中没用模板参数，函数体内才有用，也就意味着无法通过参数推演 T 的类型，只能显示实例化。

💦 函数模板的匹配规则

  1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
//专门处理int的加法函数q	
int Add(int left, int right)
{
	return left + right;
}
//通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
int main()
{
	//模板匹配原则：
	//1、有现成完全匹配的，就直接调用，没有现成调用的，实例化模板生成
	Add(1, 2);
	//2、有需要转换匹配的，那么它会优先选择去实例化模板生成
	Add(1.1, 2.2);
	return 0;
}

📝说明

Add(1, 2)：

比如说，今天你回家了，着急吃饭，家里没有人，你吃饭有两种方式，用妈妈给你的钱点外卖、冰箱里有菜自己做，那肯定是点外卖。编译器也是一样，第一个是现成的，直接调用就行，第二个编译器还要根据实参推导形参生成。所以编译器它会去调用第一个函数。

Add(1.1, 2.2)：

镇上没有外卖，只能自己做。所以它会去调用第二个函数。

如果你妈不想让你点外卖，你必须得自己做 ❓

显示实例化：Add<< int >(1, 2);

  1. 对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
//通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); //与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); //模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}
  1. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

小结：完全匹配 > 模板 > 转换匹配

avatar
文章
阅读
粉丝