目录
1.模板引入
如果现在让你设计一个通用的加法函数，你会采用什么办法？似乎目前只有函数重载。但重载函数有它的缺陷：太繁琐，只要增加了新的类型，就必须重载一个与之对应的加法函数。同时因为充值该的函数只有类型不同，所以代码的复用率较低。
为了应对在某些情况下函数重载的缺陷，引入泛型编程。
2.泛型编程
泛型编程：编写与类型无关的代码，是代码复用的一种手段。模板是泛型编程的基础。
模板的理解：在C++中存在一个模具，通过给这个模具添加不同的材料(类型)，来获得不同的产品(生成具体类型的代码)。
模板又分为函数模板与类模板。
3.函数模板
(1)函数模板概念
概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被实例化，根据实参产生函数的特定类型版本。
(2)函数模板格式
既然是模板，那就应该先知道模具是怎样的。
函数模板的主体部分和正常的函数相比，只有类型的部分不同。函数模板中的类型是需要用一个新的语法声明的。
格式1：template<typename T1,typename T2……，typename Tn> 返回值类型 函数模板名(参数列表){}
格式2：template<class T1,class T2……，class Tn> 返回值类型 函数模板名(参数列表){}
typename 与 class在此处的作用是相同的，都是告诉编译器T是一个模板参数。
(3)函数模板实例化
上面介绍了函数模板的语法，下面来看一下它的使用，也称为实例化。函数模板的实例化分为隐式实例化和显式实例化。
[1]隐式实例化
隐式实例化是指，用户只需要传参，而参数的具体类型交给编译器推演。
代码一：实现通用加法函数。
要点：两个参数类型可能不同，所以需要声明两个不同的模板参数。注意这种写法是错误的：template<typename T1,T2>。
//代码一
#include "iostream"
using namespace std;
template<typename T1,typename T2>
void Add(T1 t1,T2 t2) {
cout << "T1:" << typeid(t1).name() << endl;
cout << "T2:" << typeid(t2).name() << endl;
cout << t1 + t2 << endl;
}
int main() {
Add(12, 1.1);
}如下是代码一打印结果：可以看到，隐式实例化中，编译器会自动推演参数类型。
代码二：使用时的坑！
此代码会报错，原因在于，编译器在编译时，看到12就会将T推演为int类型，看到1.1就会将T推演为double类型，可是模板参数中只有一个类型T，编译器不知道到底该把它确定为什么类型就会报错。
会不会有人想，编译器难道不会进行类型转换吗？在模板中，一般是不会的，不然出错了怎么办？
遇到这种类型代码，除了像代码一声明两个模板参数外，还可以在传参时就进行强制类型转换，把两个参数转为同一个类型，或者使用下文中的显式实例化。
//代码二
#include "iostream"
using namespace std;
template<typename T>
void Add(T t1,T t2) {
cout << t1 + t2 << endl;
}
int main() {
Add(12, 1.1);
}[2]显式实例化
显式实例化：用户直接指定参数类型。
使用方法：使用函数时在函数名后的<>中指定模板参数的实际类型。
代码三：
//代码三
#include "iostream"
using namespace std;
template<typename T1,typename T2>
void Add(T1 t1,T2 t2) {
cout << "T1:" << typeid(t1).name() << endl;
cout << "T2:" << typeid(t2).name() << endl;
cout << t1 + t2 << endl;
}
int main() {
Add<int,int>(12, 1.1);
}下图是代码三的打印结果：可以看到，因为在<>里面提前告诉编译器，所以编译器把13.1也当作了int类型。
(4)函数模板原理
这里需要明白一点，函数模板只是模具，它不是函数！
验证上面这句话，需要来看一下代码四和它的汇编：
代码四：
//代码四
#include "iostream"
using namespace std;
template<typename T1,typename T2>
void Add(T1 t1,T2 t2) {
cout << "T1:" << typeid(t1).name() << endl;
cout << "T2:" << typeid(t2).name() << endl;
cout << t1 + t2 << endl;
}
int main() {
Add(1, 2);
Add(1.1, 2.3);
}
下图是代码四的汇编，对此进行了处理：在汇编中，call就代表着函数调用，画红线的是函数地址，可以看到，两个Add函数的入口地址并不同，也就证明了，函数模板并不是函数。(如果是函数，那么两个Add调用的就应该是同一个才对，入口地址不就一样了吗)
这也证明了一点，编译器会在类型推演后，内部生成对应的函数并调用，只是我们看不见罢了。
(5)模板参数匹配原则
[1]一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数(显式实例化)。(一切交给汇编来证明~~)
代码五：
//代码五
#include "iostream"
using namespace std;
template<typename T1,typename T2>
void Add(T1 t1,T2 t2) {
cout << "T1:" << typeid(t1).name() << endl;
cout << "T2:" << typeid(t2).name() << endl;
cout << t1 + t2 << endl;
}
void Add(int a, int b) {
cout << a + b << endl;
}
int main() {
Add(1, 2);//调用 void Add(int a, int b)
Add<int,int>(1, 23);//调用根据函数模板在内部生成的函数
}下图是代码五的汇编指令：看到了吗，两个Add函数的地址是不同的，足以证明上述结论。
[2]对于非模板函数和同名函数模板，如果其他条件都相同时会优先调用非模板函数，而不会从该模板产生出一个实例(前提是不显式实例化)。如果模板可以产生一个具有更好匹配的的函数，那么将选择模板。
其实这一点在代码五的汇编中也体现了出来。
[3]模板不允许自动类型转换，但普通函数可以进行自动类型转换。
代码六：将非模板函数注释后，此代码将会报错。解开注释后才会正常运行。
//代码六
#include "iostream"
using namespace std;
template<typename T1>
void Add(T1 t1, T1 t2) {
cout << t1 + t2 << endl;
}
//void Add(int a, int b) {
// cout << a + b << endl;
//}
int main() {
Add(1, 2.3);
}4.类模板
函数都有了模板，类自然也是有的。
(1)类模板定义格式
格式1：template<typename T1,typename T2……，typename Tn> class 类模板名{类内成员定义}
格式2：template<class T1,class T2……，class Tn> class 类模板名{类内成员定义}
代码六：类中定义一个T类型的数组
//代码六
#include "iostream"
using namespace std;
template<typename T>
class VECTOR {
public:
T arr[10];
};
int main() {}(2)类模板实例化
类模板的实例化与函数模板的实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可。与函数模板相同，类模板也不是真正的类，实例化的结果才是真正的类。
代码七：实例化代码六，<int>告诉编译器生成的类中的数组是int类型。
//代码七
#include "iostream"
using namespace std;
template<typename T>
class VECTOR {
public:
T arr[10];
};
int main() {
VECTOR<int> v1;
v1.arr[0] = 12;
cout << v1.arr[0];//输出 12
}
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
