是泛型编程的一种概念,即不考虑类型的编程,是实现代码重用的一种重要机制。
模板分为 函数模板 和 类模板
1.函数模板
有些场景,人们需要实现某些功能,只是因为类型不同,就要重写很多重复的代码此时就可以通过 函数模板 来解决。
#include <iostream>
using namespace std;
template <typename T>//类型参数化
//template 声明模板的关键字,告诉编译器,要开始声明虚拟类型了
//typename 虚拟类型的关键字
// T 虚拟类型的名字 就可以在后面使用了:用来定义变量 作为返回值类型 形参类型 都可以
// <> 类型形参表
// 虚拟类型的作用范围 只在下面的一个函数 再往后使用就不行了,需要重新声明
T my_add(T a,T b){
cout<<"模板"<<endl;
return a+b;
}
int my_add(int a,int b){//普通函数和模板函数构成重载
cout<<"普通"<<endl;
return a+b;
}
int main(int argc, const char *argv[])
{
int a = 10;
int b = 20;
double d1 = 3.14;
double d2 = 4.28;
cout<<my_add(a,b)<<endl;//如果有普通函数,优先调用普通函数
//如果没有,就调用模板函数
cout<<my_add<int>(a,b)<<endl;//可以通过类型实参表 指定调用模板函数
cout<<my_add<double>(d1,d2)<<endl;//7.42
//<int> <double> 是类型实参表 是用来给类型传参的
cout<<"------------------"<<endl;
string s1("abc");
cout<<my_add<string>(s1,s1)<<endl;
return 0;
}
可以定义多个虚拟类型:
#include <iostream>
using namespace std;
template <typename T1,typename T2>
T1 my_add(T2 a,T2 b){
return a+b;
}
//T1 和 T2的作用范围到上面的函数结束就截止了
//下面如果还要用 需要重新声明
T1 my_sub(T2 a,T2 b){
return a-b;
}
int main(int argc, const char *argv[])
{
double a = 100.1;
double b = 200.2;
//需要用<>给类型传参 传参规则 尖找尖 圆找圆
//传参遵循从左到右的原则
int ret = my_add<int,double>(a,b);//300
cout<<ret<<endl;
return 0;
}
2.类模板
有些场景,人们需要封装某些变量核函数,只是因为类型不同,就要重写很多重复的代码
此时就可以通过 类模板 来解决。
格式:
template <类型形参表>
class 类模板名{
//成员变量和成员函数
};
类型形参表 : typename T1 也可以用 class T1
一般用的都是typename 防止代码阅读混乱
类内声明,类外定义格式:
返回值类型 类模板名<类型参数>::函数名(函数的形参表){
//函数体
}
定义模板类对象格式:
类模板名<类型实参表> 模板类对象名(构造函数实参表);
例:
#include <iostream>
using namespace std;
template <typename T1,typename T2>
//声明虚拟类型后,在下面的类中就可以使用虚拟类型定义成员变量
//或者最为成员函数的参数和返回值了
class MyPair{
private:
T1 key;
T2 value;
public:
MyPair(){}
MyPair(T1 k,T2 v);
void show(){
cout<<"key:"<<key<<" "<<"value:"<<value<<endl;
}
};
template <typename T1,typename T2>//类内声明,类外定义时,类外的定义处前面也要
//重新声明虚拟类型,否则报错,因为虚拟类型的作用范围
//就是下面的一个 {}
//如果每个函数都类内声明类外定义,那么每个函数前都要加
MyPair<T1,T2>::MyPair(T1 k,T2 v):key(k),value(v){}
int main(int argc, const char *argv[])
{
//<int,string> 告诉编译器 实例化p1对象时使用的时 int string 两个类型
MyPair<int,string> p1(1001,"小明");
MyPair<string,char> p2("小红",'A');
p1.show();
p2.show();
return 0;
}
3.函数模板/类模板的实现机制?
--笔试面试可能会问到
采用 “二次编译” 机制 ----延时编译
当编译器第一次"看到"函数模板或类模板时,
以为类型尚不确定,只做与类型无关的语法检查
如果无误,则生成模板的内部表现形式。
当编译器第二次"看到"函数模板或类模板时,
会根据实际传递的类型,再次进行语法检查,
如果无误,则生成函数或类的内部表现形式。