文章目录
- 模板
- 函数模板
- 函数模板的实例化
- 类模板
- 总结
模板
模板是C++种为了方便用户对于一些场景的使用，引入的新概念，使得我们的代码不会冗余
template关键字
template关键字的意思就是模板，语法为：template<typename T1,typename T2.....,typename Tn>
使用语境
我们需要对于多种类型进行交换的时候，Swap函数的使用，在C++模板之前/C语言中，我们只能多次书写不同类型参数的Swap函数，但是现在我们可以使用模板，让编译器自动识别我们传进去的参数的类型，也就是Swap函数只需要写一次
//使用方式为：
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
template<typename T> ///模板是支持多个模板参数的，如果说需要对于两个不同类型进行交换，那就创建两个模板参数 template<typename T1,typename T2>
void Swap(T& a,T& b)
{
T tmp=a;
a=b;
b=tmp;
}
int main()
{
int a=1,b=2;
double c=1.1,d=2.2;
A a1(2);
A a2(3);
Swap(a,b);
Swap(c,d);
Swap(a1,a2);
return 0;
}
模板中的typename也可以使用class来替换，为了方便，class是比较好用的
模板类型
模板分为类模板和函数模板，对于我们上述的Swap函数使用模板，这就是函数模板，类模板是在类中的成员中使用模板
模板的作用范围
模板只能作用域该语句下面第一个函数/类，所以每当创建一个函数/类模板时，就需要重新使用模板声明
函数模板
函数模板表示为一个函数家族，可以套用任意类型的参数来使用该函数，所以函数模板与类型无关，在使用的时候能被参数化，根据实参的类型推理函数特定的类型（这些都是编译器来实现的）
**使用模板**
**template <typename T1,typename T2……typename Tn> **
**返回值类型 + 函数名 （参数列表）{}**
我们是可以在返回值类型中/参数列表中使用T，但是对于一个函数而言，T是整个函数的一种变量，不能又是int又是double
template<typename T>
void Swap(T& a,T& b)
{
T tmp=a;
a=b;
b=tmp;
}
template<typename T1,typename T2>
void Swap(T1& a,T2& b)
{
T1 tmp=a;
a=b;
b=tmp;
}
int main()
{
int a=0;
double b=1.1;
return 0;
}
typename表示的是类型名字，可以用class来替换，但是struct不行（为了和结构体避开）
函数模板本身不是严格意义上的函数，是编译器根据传参类型进行自动生成的特点具体类型函数，所以编译器实际上是做了我们不愿意重复做的事情
函数模板的实例化
定义：用不同类型的参数使用函数模板的时候，称为函数模板的实例化，实例化分为两种一种是隐式实例化，另一种是显示实例化
隐式实例化
//让编译器根据我们传递的实参的类型推演模板参数的类型
template<typename T>
void Swap(T& a,T& b)
{
T tmp=a;
a=b;
b=tmp;
}
int main()
{
int a=10,b=20;
double c=1.1,d=2.2;
Swap(a,b);//T识别为int类型
Swap(c,d);//这个情况T识别为double类型
Swap(a,c);//这种情况会报错，因为编译器无法识别T到底是int还是double类型，在模板中编译器一般不会自动进行类型转换
return 0;
}
为了解决上面多类型单模板的问题，我们可以通过两个方式来解决，1.手动强制转换（传参时候强转）2.显示类型转换
显示类型转换
//对于上述问题，我们两种方法处理
//让编译器根据我们传递的实参的类型推演模板参数的类型
template<typename T>
void Swap(T a,T b)
{
T tmp=a;
a=b;
b=tmp;
}
int main()
{
int a=10,b=20;
double c=1.1,d=2.2;
Swap(a,(int)c);//或者是Swap((double)a,c);//就是在传参的时候就将两个实参统一为同一类型
//第二种方法，显示类型转换
Swap<int>(a,c)//说明使得模板的类型为int类型
Swap<double>(a,c);//double
return 0;
}
显示转换，实际上就是我们让编译器认为模板类型就是<类型>括号中的类型
但是我们要知道的是，使用显示转换，或者自己传参强制转换的时候，不能使用&的，因为我们只是强制转换的，但是原有类型是没办法变的
当同时有模板函数和同名非模板函数时，在其他条件相同（只是一个用模板一个不用）在调用时候会优先调用非模板函数，如果模板可以产生一个具有更好匹配的函数，那么优先模板
template<typename T1,class T2>
int add(T1& a, T2& b)
{
return a + b;
}
int add(int& a, double& b)
{
return a + b;
}
int add(int& a, int& b)
{
return a + b;
}
int main()
{
int a = 10, b = 20;
double c = 1.1, d = 2.2;
add(a, c);
add(a, b);
return 0;
}
模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
所以模板函数有显示实例化<>就是为了让编译器知道我们想要的类型是什么
类模板
类模板，就是一个类，和普通类是一样的，只是这个类中的成员变量中有模板参数typename T,当我们使用这个类的时候，编译器会根据我们的实例化类，来生成对应的类型
//下面是演示过程
class A
{
public:
void Print()
{
cout<<_a<<endl;
}
T get_a()
{
return _a;
}
private:
T _a;
};
int main()
{
A<int>a;
a.Print();
return 0;
}
语法：
template<class T1,class T2,…,class Tn>
class 类模板名
{
//类中成员定义（成员函数/成员变量）
}
template<class T>
class A //A就是模板名字
{
public:
void Print()
{
cout << _a << endl;
}
T get_a();
private:
T _a;
};
template<class T>
T A<T>::get_a()
{
return _a;
}
#include<vector>
int main()
{
A<int>a;
vector<int>a;
a.Print();
return 0;
}
类模板的实例化
类模板的实例化是需要在<>中确认类型的（不然编译器不知道如何定义T类型）如：vector<int>a （int类型的容器vector）
类模板的实例化需要在类模板名字后面跟着<>,然后将实例化的类型放在<>中即可，类模板不是真正的类，实例化的结果才是类
总结
模板分为函数模板和类模板
函数模板
- 函数模板不是函数，实例化之后的才是函数
类模板
- 类模板也不是真正意义上的类，实例化的后的结果才是类
函数模板和类模板实例化都是由编译器处理的，所以我们只需要给他实例化的类型即可
函数模板的实例化分为隐式实例化和显示实例化，隐式就是不需要<类型>，显示的需要<类型>
函数模板的显示实例化：一般是处理单个模板参数对多个类型的实参时候<类型>，<>中的类型决定最后返回类型（指定模板参数的实际类型）
template<class T>
T add(T a, T b)
{
return a + b;
}
int main()
{
int b = 10;
double c = 1.1;
//两个类型传参，我们规定的是<double>类型，所以T类型为double，所以传参的时候隐式转换
c=add<double>(c, b);//如果是add<int>(c,d)输出结果为11
cout << c << endl;//输出为11.1
return 0;
}
类模板和模板类
说明：模板类是类模板实例化后的一个产物，比如说，我们拿着杯子，想去接一杯饮料，你想要可乐，那就去接可乐，想要雪碧就去接雪碧，那么可乐、雪碧这就是我们实例化产生的产物，根据我们的意愿产生的，这就是由类模板得到的模板类
类模板和模板类，前者注重模板，后者注重类，也就是说，类模板并不是一个真正意义上的类，而类模板实例化之后的产物才是真正意义上的类（编译器处理，我们来选定模板参数类型），这样得到的也就是模板类
