目录
1.模板引入
2.泛型编程
3.函数模板
(1)函数模板概念
(2)函数模板格式
(3)函数模板实例化
[1]隐式实例化
[2]显式实例化
(4)函数模板原理
(5)模板参数匹配原则
4.类模板
(1)类模板定义格式
(2)类模板实例化
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
}
更多推荐
C++模板初阶
发布评论