C++函数模板的详细讲解【函数模板的概念、用法及其模板函数的概念知识】

前言

C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。

C++函数模板的使用

为什么要有函数模板

例如，在一个项目中，有个项目需求是能够实现多个函数用来返回两个数的最大值，要求能支持char类型、int类型、double类型变量。然后呢，根据这个需求，我们写了以下这个代码。

#include 

using namespace std;

//比较int 类型
int Max(int a, int b)
{
	return a > b ? a : b;
}

//比较char 类型
char Max(char a, char b)
{
	return a > b ? a : b;
}

//比较float 类型
float Max(float a, float b)
{
	return a > b ? a : b;
}

int main(void)
{

	int  n = 1;
	int	 m = 2;
	cout << "max(1, 2) = " << Max(n, m) << endl;

	float a = 2.0;
	float b = 3.0;
	cout << "max(2.0, 3.0) = " << Max(a, b) << endl;

	char i = 'a';
	char j = 'b';
	cout << "max('a', 'b') = " << Max(i, j) << endl;

	return 0;
}

执行得到

我们看到，如果我们需要比较多个类型时，需要多个函数，而实际上我们只需要定义一个 “函数” 就能解决。

#include 

using namespace std;

//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T>
T Max(T a, T b) {
	return a > b ? a : b;
}

int main(void)
{

	int  n = 1;
	int	 m = 2;
	cout << "max(1, 2) = " << Max(n, m) << endl;

	float a = 2.0;
	float b = 3.0;
	cout << "max(2.0, 3.0) = " << Max(a, b) << endl;

	char i = 'a';
	char j = 'b';
	cout << "max('a', 'b') = " << Max(i, j) << endl;
	
	return 0;
}

得到的结果是一样的

我们在定义一个函数模板之后，，没有指定类型，编译器会实现参数类型的自动推导。

函数模板语法

所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。

凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

函数模板定义形式
由以下三部分组成： 模板说明 + 函数定义 + 函数模板调用

template < 类型形式参数表 >
类型 函数名 (形式参数表)
{
//语句序列
}

我们也可以定义多个类型

template <typename T, typename T2>

但是我们定义了一定要用，否则会报错

将代码改成

#include 

using namespace std;

//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
	return a > b ? a : b;
}

int main(void){

	int n = 6;
	int m = 9;

	cout << Max(n, m) << endl;

	system("pause");
	return 0;
}

1.模板说明

template < 类型形式参数表 >
类型形式参数的形式：
typename T1 , typename T2 , …… , typename Tn
或 class T1 , class T2 , …… , class Tn
（注意： typename 和 class 的效果是一样的，不过建议呢使用typename，为了防止用class有歧义）

2.函数定义

类型 函数名 (形式参数表)
{
}
注意： 模板说明的类属参数必须在函数定义中出现一次,函数参数表中可以使用类属类型参数，也可以使用一般类型参数

3.函数模板调用

Max(a, b); //显式类型调用
Max(a, b); //自动数据类型推导

我们再来看以下代码

#include 

using namespace std;

//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
	return a > b ? a : b;
}

int main(void){

	int n = 6;
	int m = 9;
	char a = 'c';	//'c' 对应的ascll码值是 99

	cout << "Max(m, a): " << Max<int, char>(m, a) << endl;	//显式类型调用
	cout << "Max(m, a): " << Max(m, a) << endl;	//自动数据类型推导

	cout << "Max(a, m): " << Max(a, m) << endl;	//自动数据类型推导
	
	return 0;
}

为什么会这样呢？因为我们在定义函数模板的时候第一个类型作为了函数类型。

模板函数

也就是，在我们编译的时候，编译器内部会自动生成这些模板函数，然后再进行调用，当然，这些都是编译器内部生成的，我们可以不用去了解太深，我们知道这个概念就可以了。

如果我们来比较类的两个对象

#include 

using namespace std;

//定义一个类
class Son {
public:
	Son(int age) { m_age = age; }
	~Son(){}

	int getAge() { return m_age; }


private:
	int m_age;
};

//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
	return a > b ? a : b;
}

int main(void){
	Son s1(18);	
	Son s2(21);

	cout << "Max(s1, s2): " << Max(s1, s2).getAge() << endl;
	/*
	* 模板函数 在类的对象中， 不认识 > 这个符号
	Son Max(Son s1, Son s2){
		return a > b ? a : b;
	}
	*/
	return 0;
}

就会出现这样的错误

因为在类对象的比较中，不认识这个 > 的符号，所以我们想要能成功执行，我们得在类中实现 > 的运算符重载

#include 

using namespace std;

//定义一个类
class Son {
public:
	Son(int age) { m_age = age; }
	~Son(){}

	int getAge() { return m_age; }

	//重载 > 运算符
	bool operator >(Son& res) {
		if (this->m_age > res.m_age) return true;

		return false;
	}


private:
	int m_age;
};

//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
	return a > b ? a : b;
}


int main(void){
	Son s1(18);	
	Son s2(21);

	cout << "Max(s1, s2): " << Max(s1, s2).getAge() << endl;
	/*
	* 模板函数 在类的对象中， 不认识 > 这个符号
	Son Max(Son s1, Son s2){
		return a > b ? a : b;
	}
	*/
	return 0;
}

这样就可以执行得出结果了

函数模板和函数重载

我们先来看一下这个demo

#include 

using namespace std;

template <typename T>
void Test(T& a, T& b) {
	T c;
	c = a;
	a = b;
	b = c;

	cout << "Test 函数模板被调用了.." << endl;
}

void Test(int& a, int& b) {
	int c;
	c = a;
	a = b;
	b = c;

	cout << "Test 普通函数被调用.." << endl;
}


int main(void) {
	int n = 99;
	int m = 65;

	Test(n, m);
	
	return 0;
}

这是来观察，当存在函数模板和普通对应的函数的时候，会调用哪个函数

可以看到 当函数模板和普通函数并存的时候，参数类型会和普通重载函数更加匹配

我们把普通函数注释掉，我们才能看到调用函数模板

如果普通函数和函数模板都在的情况下，我们非要使用函数模板，这个怎么实现呢，很简单，如果显式的使用函数模板,则使用<> 类型列表。

如果我们将一个传递的参数改为别的类型

不存在对应的普通函数，函数模板不会提供隐式的类型转换，必须是严格的类型匹配

函数模板和普通函数区别结论：

两者允许并存
函数模板不允许自动类型转化

如果有函数模板和普通函数的时候，普通函数的参数类型不不一致的时候，也会调用普通函数，因为会有隐式的转换，但是如果有函数模板的时候，函数模板会产生更好的匹配，使用函数模板。

有更好的函数模板的时候，会选择函数模板

嵌套使用函数模板

在函数模板中，我们也可以嵌套使用函数模板。

#include 

using namespace std;

template<typename T>
T Max(T a, T b)
{
	cout << "调用 T Max(T a, T b)" << endl;
	return a > b ? a : b;
}

template <typename T>
T Max(T a, T b, T c) {
	cout << "调用 T Max(T a, T b, T c)" << endl;
	return Max(Max(a, b), c);
}

int main(void) {
	int a = 1;
	int b = 2;
	int c = 3;

	Max(a, b, c);

	system("pause");
	return 0;
}

注意：嵌套中的函数要声明在这个函数之前，否则编译器会找不到哪个函数，然后会报错

函数模板和普通函数在一起，调用规则

1 函数模板可以像普通函数一样被重载
2 C++编译器优先考虑普通函数
3 如果函数模板可以产生一个更好的匹配，那么选择模板
4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

在Linux中反汇编查看函数模板被调用的机制

在Linux创建一个cpp文件

保存退出之后编译生成指定的汇编的文件

然后查看这个汇编文件，找到我们熟悉的main函数


再执行一个有函数模板的CPP文件

在main函数中调用了函数模板



从上面可以看出，我们只是定义了一个函数模板，而在调用的时候，内部会自动帮我们生成一个模板函数，然后再执行这个模板函数，得到我们想要的结果

结论

1. 编译器并不是把函数模板处理成能够处理任意类型的函数
2. 编译器从函数模板通过具体类型产生不同的函数