可能有的人像以前的码神一样，学了一年多都不知道函数模板究竟是个什么东东，究竟有什么用，这可谓是秋名山一路下来，不知道有个排水渠过湾一样，哈哈，话不废话，直接上正题了。 定义 函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。 这他妈的，god知道是什么东西啊！
那就写用法吧： 这里引用c primer中的一个案例swap函数
代码语言：javascript复制void swap(int &a,int &b)//int
{
int temp;
temp=a;
a=b;
b=temp;
}
void swap1(double &a,double &b)
{
int temp;
temp=a;
a=b;
b=temp;
}可以看出，我为了实现交换的操作，需要写俩个函数，尽管他们的用途几乎是一致的，此时周董的黑白ae86——函数模板就来了，再看：
代码语言：javascript复制template <class T>
void Swap(T & x, T & y)
{
T tmp = x;
x = y;
y = tmp;
}这个就是函数模板，书中的解释是这样的 T 是类型参数，代表类型。编译器由模板自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编译到调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数。
下面给大家写一个完整的模板
代码语言：javascript复制#include <iostream>
using namespace std;
template<class T>
//其中class可以替换为typename
//template<typename T>
void swap(T & x, T & y)
{
T tmp = x;
x = y;
y = tmp;
}
int main()
{
int n = 1, m = 2;
swap(n, m); //编译器自动生成 int 函数
double f = 1.2, g = 2.3;
swap(f, g); //编译器自动生成 double 函数
return 0;
}其中的原理就是，编译器找不到，函数Swap的类型，但是发现，我们传入的n，m都是int类型，所以自己用int来代替函数模板中的T
要实现函数模板的理解，我们还应该了解专业术语：
- 实例化：1 实例化 实例化有两种形式，分别为显式实例化和隐式实例化。模板并非函数定义，实例式函数定义。
1.1 显式实例化（explicit instantiation） 显式实例化意味着可以直接命令编译器创建特定的实例，有两种显式声明的方式。
比如存在这么一个模板函数
template void Swap(T &a, T &b)
第一种方式是声明所需的种类，用<>符号来指示类型，并在声明前加上关键词template，如下： template void Swap(int &, int &);
第二种方式是直接在程序中使用函数创建，如下：
Swap(a,b);
显式实例化直接使用了具体的函数定义，而不是让程序去自动判断。
1.2 隐式实例化（implicit instantiation） 隐式实例化比较简单，就是最正常的调用，Swap(a,b)，直接导致程序生成一个Swap()的实例，该实例使用的类型即参数a和b的类型，编译器根据参数来定义函数实例。
- 具体化：思考这么一个问题，当前的Swap模板交换输入的两个对象，可能式基本类型也可能式自定义类。如果有这么一个需求，需要交换自定义类里的某一个属性而不是整个类，那么Swap模板就不可用，因为Swap模板交换的是整个类。 显式具体化将不会使用Swap()模板来生成函数定义，而应使用专门为该特定类型显式定义的函数类型。有两种定义形式，如下，其中job为用户自定义类 template <> void Swap(job &a, job &b) template <> void Swap(job &a, job &b) 显式具体化在声明后，必须要有具体的实现，这是与显示实例化不同的地方。
下面我们再来模仿一个程序来具体看一下
代码语言：javascript复制#include<iostream>
#include<string>
using namespace std;
struct job
{
string name;
int salary;
job(string _name,int _salary):name(_name),salary(_salary){};
};
//template prototype
template <typename T>
void Swap(T &a, T &b){
T temp;
temp = a;
a = b;
b = temp;
}
//explict specialization for job 显式具体化
template <> void Swap(job &a, job &b)
{
int temp;
temp = a.salary;
a.salary = b.salary;
b.salary = temp;
}
template void Swap<int>(int &, int &);
int main()
{
char a = 'a', b = 'b';
cout<<"a: "<<a<<" ; b: "<<b<<endl;
Swap(a,b); //1 implicit template instantiation for char 隐式实例化
cout<<"a: "<<a<<" ; b: "<<b<<endl;
int c = 1, d = 2;
cout<<"c: "<<c<<" ; d: "<<d<<endl;
Swap(c,d); //2 use explicit template instantiation for int 显式实例化
cout<<"c: "<<c<<" ; d: "<<d<<endl;
Swap<int>(c,d); //3 use explict template instantiation for int 显式实例化
cout<<"c: "<<c<<" ; d: "<<d<<endl;
job e("lucy",100), f("bob",200);
cout<<"lucy: "<<e.name<<" "<<e.salary<<" ; bob: "<<f.name<<" "<<f.salary<<endl;
Swap(e,f); //use explict specialization for job 调用显式具体化
cout<<"lucy: "<<e.name<<" "<<e.salary<<" ; bob: "<<f.name<<" "<<f.salary<<endl;
}如果感觉不错，欢迎点赞评论！
