如果我们想要实现一个通用的交换函数，在C语言中，我们大概要定义无数个参数不同的交换函数，并且它们的函数名需要各不相同，相信这样的调用便会非常困难，想要调哪个函数还要记得对应的函数名。在C++中，有了重载的概念，这样我们可以相对方便的实现通用的交换函数，但是还是非常麻烦，但是今天的知识将会极大地改变这种情况。我们只需定义一个模板，编译器就会根据这个模板生成对应的函数。

一、函数模板

#include<iostream>
using namespace std;
//template<typename 变量名, typename 变量名, ......, typename 变量名>
template<typename T>
void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	//Date* p1 = new Date[10]{ {1,2,3}, {2,3,4} };
	float a = 4.6;
	float b = 3.9;
	Swap(a, b);
	int c = 7;
	int d = 8;
	Swap(c, d);
	cout << a << ' ' << b << endl;
	cout << c << ' ' << d << endl;
	return 0;
}

       这里的交换函数交换的是同类型的变量，模板只需接受一个参数。若有几个不同类型，那就定义几个不同的变量。

       调试程序，我们会发现不同的类型调用的交换函数貌似都是一个，但是实际上它们调的不是一同个函数。如下图所示：

       转到反汇编，我们可以看到两个swap调用的并不是同一个函数，它们各自的swap函数的地址不同。

       模板的作用只是按我们的需求帮我们实现足够数量的函数。它省去了我们实现大量不同参数类型的交换函数的步骤。

       其实，交换函数已经被纳入到库里面了，成为了一个库函数，我们需要的时候直接调用即可。它的函数名是swap。

       若一个函数中有多个参数，那这个时候怎么生成模板呢?

template<typename T>
T Add(T a, T b)
{
	return a + b;
}

int main()
{
	//Date* p1 = new Date[10]{ {1,2,3}, {2,3,4} };
	int a = 1;
	float b = 2.3;
	cout << Add(a, b) << endl;
	return 0;
}

       若强制写成上面这段代码的形式，那么编译器会报错。我们可以显示实例化a和b，意思是，告诉编译器，a和b的类型是什么。因为生成模板函数之前会有一个推演的过程，推出来a和b的对象是什么类型的。如果类型有冲突那么就报错。我们显示实例化a和b，就是告诉编译器它们的类型是什么。

template<typename T>
T Add(T a, T b)
{
	return a + b;
}

int main()
{
	//Date* p1 = new Date[10]{ {1,2,3}, {2,3,4} };
	int a = 1;
	float b = 2.3;
    //显示实例化 <>
	cout << Add<int>(a, b) << endl;
	return 0;
}

       上面这段代码的意思是将a和b都转换为int类型。其中b会进行隐式类型转换，不同类型进行类型转换会有可能丢失数据。

       那想要获得不同类型相加的返回值，我们可以使用auto做返回类型，就是让编译器自动推到返回的类型。

template<typename T1, typename T2>
auto Add(T1 a, T2 b)
{
	return a + b;
}

int main()
{
	//Date* p1 = new Date[10]{ {1,2,3}, {2,3,4} };
	int a = 1;
	float b = 2.3;
	cout << Add<int>(a, b) << endl;
	return 0;
}

       模板函数和非模板函数可以同时存在，若调用的参数类型完全符合非模板函数，那么就会优先调用非模板函数，若调用参数类型不符合非木板函数，那么就会调用模板函数。