起初，我们写不同类型的加法函数是这样写的吧：

//Template.h

#pragma onceint Add(const int left,const int right)
{return left+right;
}char Add(const char left,const char right)
{return left+right;
}float Add(const float left,const float right)
{return left+right;
}</span>

//Template.cpp

int main()
{cout<<Add(1,2)<<endl;cout<<Add('1','2')<<endl;cout<<Add(1.1f,2.2f)<<endl;return 0;
}

运行结果：

是不是特别熟悉呢。对，这就是我们的函数重载。之前为了适应不同类型的参数，我们一直使用的函数重载的方式。但是这种方式有一定的局限性和缺点，比如：

（1）只要有新类型出现，就得新添加函数。

（2）重复的代码过多，代码复用率不高。

（3）如果只是函数返回值不同，就不能使用函数重载。

（4）一个方法有问题，所有的方法都有问题，不好维护。

那么，我们还知道什么方法可以解决这些问题呢？

肯定有人会说，使用宏定义的方法。

#define Add(a,b) ((a)+(b))

运行结果：

显然，上述两种方式打印出来的结果竟然不相同。这是为什么呢？

首先，用宏定义的方式没有类型检测，所以致使第二次打印char类型的值时打印成了int型，这样也使得代码安全性不高。

其次，宏不是函数，不能调试，如果出错的话，也会很麻烦。

这里，就给大家引入一个新的概念吧~【模板】

模板是泛型编程的基础，那么，泛型编程指什么呢，就是编写与类型无关的逻辑代码。

模板分为函数模板和类模板，今天给大家讲一下函数模板。

一、函数模板

模板的格式：

template<typename T1,typename T2 ...>  【说明：typename是模板参数关键字，T1，T2是类型名】

那么，对于上述的加法问题，我们就可以写成这样的：

//Template.h

template<typename T>
T Add(const T& left,const T& right)
{return left+right;
}

//Template.cpp

int main()
{cout<<Add(1,2)<<endl;cout<<Add('1','2')<<endl;cout<<Add(1.1f,2.2f)<<endl;return 0;
}</span>

运行结果：

这样的结果也是和函数重载方式的结果是一样的。

我们可以想到，模板函数的类型是T，而传入的参数是固定的类型，它是怎么检测到函数的类型的呢。这里就有模板函数的推演过程。

查看反汇编，当调用第一个Add(1,2)时，

当调用Add('1','2')时：

当调用Add(1.1,2.2)时：

其实背后的推演为这样的（编译器会自动的生成相应的函数）：

二、模板参数

函数模板有两种类型参数：模板参数和调用参数。

模板形参分为类型形参和非类型形参。

（1）模板形参的名字只能在模板形参之后到模板声明或定义之间使用。

（2）模板形参的名字在同一模板形参列表中只能使用一次。

（3）所有模板形参前面必须加class或typename关键字。

（4）不能将模板形参作为函数实参。

还有：

（5）函数形参为离它最近的模板形参。

（6）默认的模板参数（在这里是不能使用的，只有在类模板中可使用）

三、非模板类型参数

例：对于数组长度来说，可以这样定义模板参数：

通过反汇编可以看到内部的实现：

还有另外一种调用方式是：

注：这里的数组arr的类型是int[10]，所以T代表的是int[10]哦。

总结一下，模板形参需要注意的点：

（1）模板形参表需使用<>;

（2）模板形参中参数需用逗号隔开；

（3）模板形参表不能为空；

如：

（4）模板形参可以是类型参数（跟在class/typename后），也可以是非类型参数。

（5）模板形参可作为类型说明符用在模板的任何地方，与内置类型或自定义类型使用方法相同，可用于指定函数形参类型、返回值、局部变量、强制类型转换。

（6）模板形参表中，class和typename有相同的含义，但typename更加直观，一般多用typename。（注：旧版本可能不支持typename，只支持class）

四、模板函数的特化

为什么会引入模板函数的特化版本呢？

有时候，我们并不能写出对所有可能被实例化的类型都最合适的模板，此时，我们就会用特化的形式，来实现模板函数。

例：

//Template.h

template<typename T>
T Add(const T& left,const T& right)
{return left+right;
}template<>     //特化版本
int Add<int>(const int& left,const int& right)    
{return left+right;
}

//Template.cpp

int main()
{cout<<Add(1,2)<<endl;return 0;
}

此时，Add（1，2）函数会调用哪个模板函数呢？

这里要知道，如果是特化版本中有实参类型，就直接调用特化版本。好处是：不用进行模板参数的类型推演过程。

下面再看一个例子：

//Template.h

#pragma once
#include<string.h>template<typename T>
T Max(const T left,const T right)
{return (left > right) ? left:right;
}template<>
char* Max<char*>(char* const str1,char* const str2)
{if(strcmp(str1,str2) == 0 || strcmp(str1,str2) == 1){return str1;}else{return str2;}
}

//Template.cpp

#include"Template.h"
#include<iostream>
using namespace std;
int main()
{char* str1 = "zello";char* str2 = "world";cout<<Max<char*>(str1,str2)<<endl;return 0;
}

运行结果：

注：在这里要特别注意的是const的位置，它修饰的是字符串，而不是char*哦。

模板就先说到这里啦~~

下一篇博客，会写到模板类的实现哦。欢迎大家来访喽，并给出好的建议和意见哦。