本文参照于狄泰软件学院——《C++深度剖析课程》
函数模板的工作机制
问题：函数模板的工作原理是怎么样的？如何区分类型的？跟宏定义的方式有区别吗？
1. 编译器从函数模板通过具体类型产生不同的函数
根据自动推导类型的方式，我们就可以知道，函数模板实际是根据传入的实参来判断类型的。
2. 编译器会对函数模板进行两次编译
3. 第一次编译：对模板代码本身进行编译
4. 第二次编译：对参数替换后的代码进行编译
这个机制实际就是为了解决宏定义无法对类型检查的缺陷。第一次编译检查模板函数是否存在语法错误。 第二次编译是在我们调用这个函数的时候，为了得到相对应类型的函数，会再次进行编译。
根据编译器对函数模板的二次编译我们可以知道，函数模板并不是一个实际存在的一个函数，而是产生实际函数的模子。当我们使用参数进行调用，编译器第二次编译后才会产生一个真正的函数。
函数模板的本质
问题：我们如何证明函数模板第二次编译才产生对应类型的函数呢？
示例代码：函数模板的本质
#include <iostream>
#include <string>
using namespace std;
template < typename T >
void Swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
typedef void(FuncI)(int&, int&);
typedef void(FuncD)(double&, double&);
int main()
{
FuncI* pi = Swap; // 编译器自动推导 T 为 int
FuncD* pd = Swap; // 编译器自动推导 T 为 double
cout << "pi = " << reinterpret_cast<void*>(pi) << endl;
cout << "pd = " << reinterpret_cast<void*>(pd) << endl;
return 0;
}输出结果：
pi = 0x41bbb8
pd = 0x41bb84
分析：
1. 我们可以发现，函数指针指向同一个函数，但是输出地址却不相同。
这就说明了实际上编译器为我们产生了两个参数类型不同的函数。
而产生实际函数是在我们指定特定参数类型时才产生的，也就是第二次编译。不然怎么不产生别的类型的函数呢。
多参数函数模板
问题：在我们编写函数时，不可能说函数参数都是相同的，而我们上面所讲的都是函数相同的情况。那么函数参数各不相同时，有返回值时，应该怎么定义函数模板呢？
示例代码：多参数函数模板
#include <iostream>
#include <string>
using namespace std;
template
< typename T1, typename T2, typename T3 >
T1 Add(T2 a, T3 b)
{
return static_cast<T1>(a + b);
}
int main()
{
int r1 = Add(3, 4); //Error,cannot auto Type Inference
// T1 = double, T2 = int, T3 = double
double r2 = Add<double, int>(5, 0.8);
// T1 = int, T2 = float, T3 = float
float r3 = Add<int, float, float>(0.5, 0.8);
cout << "r2 = " << r2 << endl;
cout << "r3 = " << r3 << endl;
return 0;
}输出结果：
r2 = 5.8
r3 = 1
分析：
1. int r1 = Add(3, 4); 编译器报错。为什么呢？
就是因为编译器无法自动推导返回值类型。
2. double r2 = Add
函数重载与函数模板
实际上，函数模板的实现跟函数重载有点相似。但是函数模板不需要编写大量重复的函数，而是编译器自动帮我们生成了相对应的函数。
那儿，当有一个函数重载了 模板函数，那么编译器会产生什么呀的现象呢？
示例代码：重载函数模板
#include <iostream>
#include <string>
using namespace std;
template < typename T >
T Max(T a, T b)
{
cout << "T Max(T a, T b) = ";
return a > b ? a : b;
}
int Max(int a, int b)
{
cout << "int Max(int a, int b) = " ;
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) = ";
return Max(Max(a, b), c);
}
int main()
{
int a = 1;
int b = 2;
cout << Max(a, b) << endl; // 普通函数 Max(int, int)
cout << Max<>(a, b) << endl; // 函数模板 Max<int>(int, int)
cout << Max(3.0, 4.0) << endl;
cout << Max(3, 4, 5) << endl; // 函数模板 Max<int>(int, int, int)
cout << Max(5.0, 6.0, 7.0) << endl;
cout << Max('a', 100) << endl; // 普通函数 Max(int, int)
return 0;
}输出结果：
int Max(int a, int b) = 2
T Max(T a, T b) = 2
T Max(T a, T b) = 4
T Max(T a, T b, T c) = int Max(int a, int b) = int Max(int a, int b) = 5
T Max(T a, T b, T c) = T Max(T a, T b) = T Max(T a, T b) = 7
int Max(int a, int b) = 100
分析：
1. cout << Max(a, b) << endl; 编译器并没有选择函数模板，而是优先考虑了普通函数。
2. cout << Max<>(a, b) << endl; 可以通过空模板实参列表限定编译器只匹配模板
3. cout << Max(3, 4, 5) << endl; 和 cout << Max(5.0, 6.0, 7.0) << endl; 产生一个更好的匹配时，会自动选择模板或者普通函数。
函数重载与函数模板并不冲突。当面对编译器面对选择时：
1. 当参数类型符合普通函数时，优先选择普通函数。
2. 如果函数模板可以产生一个更好的匹配，那么选择模板。
这种选择也符合我们人类的观点：有更好更方便的，优先选择。