1. 基本概念
1.1 什么是模板？
模板(Template)是允许函数或者类通过泛型(generic types)的形式表现或运行的特性。
1.2 模板有什么用？
模板可以使函数或者类只写一份代码而对应不同的类型。
1.3 模板编程/泛型编程
一种独立于特定类型的编码方式
1.4 模板分类
模板分为函数模板与类模板两类。
- 函数模板(Function template):使用泛型参数的函数(function with generic parameters)
- 类模板(Class template):使用泛型参数的类(class with generic parameters)
2. 函数模板
- 模板声明
template <模板形参表> 函数返回类型 函数(形参表);
- 模板定义
template <模板形参表>
函数返回类型 函数(形参表){
函数体;
};
例如：
template <typename T> T Max(T a,T b){
return a>b?a:b;
}
- 模板实例化
函数(实参表)
产生模板特定类型的函数或者类的过程称为实例化
调用函数模板与调用函数完全一致。
- 实例
最值函数Max(),Min()
字符串转数值Ston()
3. 类模板
- 模板声明
template <模板形参表> class 类名;
- 模板定义
template <模板形参表>
class 类名 {
}
- 模板实例化
类名<模板实参表> 对象;
- 模板参数表
多个模板参数之间,分割。模板参数,模板参数,... - 模板参数
- 类型形参
class 类型形参或者typename 类型形参
类模板的声明与实现通常都写在头文件中，是不能够分开的。
- 实例
复数类Complex
三角形类Triangle
4. 模板参数推导/推演(deduction)
模板参数推导/推演(deduction):由模板实参类型确定模板形参的过程。
实例化有两类：
显示实例化：代码中明确指定类型的实例化
隐式初始化：根据参数类型自动匹配的实例化
类模板参数允许自动类型转换(隐式转换);函数模板参数不允许自动类型转换(隐式转换)
在模板参数列表中，class和typename完全一样。但是在语义上，class表示类，typename代表所有类型(类以及基本类型)。
请尽量使用typename
函数模板实参类型不一致问题
template <typename T>
inline const T& Max(const T& a, const T& b){
return a>b?a:b;
}
模板实例化时，
Max(2,2.4)
参数推导会出现模板实参类型int与double不一致的错误。
解决方法：
- 每个模板参数独立类型
template <typename T , typename U> inline const T& Max(const T& a, const U& b){
return a>b?a:b;
}
注意：这种解决方法还有一个问题，就是返回值只能强制设置为T或者U，不能自动推导。C++11的后置推导解决这个问题。
template <typename T, typename U>
inline auto Max(const T& a, const U& b)->decltype(a>b?a:b)
{
return a>b?a:b;
}
- 显示指定模板实参类型
Max<int>(2,2.4)
或者
Max<double>(2,2.4)
- 实参强制类型转换
Max(2,static_cast<int>(2.4))
或者
Max(static_cast<double>(2),2.4)
模板参数推导不允许类型自动转换，模板参数必须严格匹配。
函数模板实例显示指定模板实参可以显示指定模板实参，也可以不指定(类型自动推导)，类模板实例化必须
5. 特化
- 模板特化(specialization):模板参数在某种特定类型下的具体实现称为模板的特化。模板特化有时也称之为模板的具体化。
特化作用
- 对于某种特殊类型，可以做特殊处理或者优化。
- 避免实例化类的时候产生诡异行为。
模板特化分类
- 函数模板特化(Function specializations)：对函数模板的全部模板类型指定具体类型。
- 类模板特化(Class specializations)：对类模板的全部或者部分模板类型指定具体类型。
5.1 函数模板特化
特点：函数模板，却只有全特化，不能偏特化。
步骤：与类的全特化相同
示例：
template<typename T>
void Func(const T& n){}
// 特化
template<>
void Func(const int& n){}
5.2 类模板特化
特点：类模板特化，每个成员函数必须重新定义。
类模板特化分为两种
- 全特化(Full specializations)：具体指定模板的全部模板参数的类型。
- 局部特化(Partial specializations)：具体指定模板的部分模板参数的类型。
5.2.1 全特化
步骤：
- 声明一个模板空参数列表
template<> - 在类名称后面的
<>中显示指定类型。
示例：
// 模板
template<class T>
class Test{};
// 全特化
template<>
class Test<int*>{};
5.2.2 偏特化
偏特化就是部分特化，分为两种情况
- 个数特化：只为部分模板参数指定具体类型(模板参数个数变少)
- 范围特化：模板参数不变，限制模板参数的匹配类型(指针、引用、const)
步骤：
- 在一个模板类参数列表不指定或者指定部分具体类型。
- 在类名称后面的对应类型中显示指定该类型。
示例：
template<typename T1,typename T2>
class Test{};
- 将模板参数偏特化为相同类型
template<typename T>
class Test<T,T>{};
- 将一个模板参数特化成具体类型
template<typename T>
class Test<T,int>{};
- 把两个类型偏特化成指针类型
template<typename T1,typename T2>
class Test<T1*,T2*>{};
实例：三元组模版Triple
类模板特化，相当于函数模板的重载
全特化和偏特化的编码区别：
全特化的模板参数列表为空template<>，偏特化的模板参数列表不为空。
模板原理
模板通常会被编译两次
- 实例化前，检查模板代码是否有语法错误。
- 实例化中，检查模板代码调用是否合法。
如何查看模板实例化的结果？https://cppinsights.io/
非类型模版参数
非类型模板的实参只能是整型常量、枚举值或者指向外部链接对象的指针。
不能使用浮点型、类对象、内部链接对象的指针。
技巧
函数模板参数尽量使用引用类型const &
例如：
template <typename T> inline const T& Max(const T& a, const T& b){
return a>b?a:b;
}
类模板
成员函数：只有调用时才会被实例化。
静态成员：每次类模板实例化，都会被实例化。
类实例化成对象，类模板实例化成类。
- 类模板：不完整的类，一个或者多个成员类型未确定。
- 函数模板：不完整的函数，一个或者多个参数类型未确定。
如何查看模板实例化的结果？https://cppinsights.io/
实例
- 函数模板重载和特化
#include <iostream>
#include <cstring>
using namespace std;
// 引用类型模板
template <typename T>
bool Equal(const T& a,const T& b){
return a == b;
}
// 特化成浮点型
template<>
bool Equal(const double& a,const double& b){
return abs(a-b) < 1e-6;
}
// -------------------------------------------------
// 指针类型模板(函数模板重载)
template<typename T>
bool Equal(const T* a,const T* b){
return *a==*b;
}
// 特化成char*
template<>
bool Equal(const char* a,const char* b){
return strcmp(a,b)==0;
}
int main(){
cout << Equal(1,1) << endl;
cout << Equal(1.2,1.2) << endl;
cout << Equal(string("abc"),string("abc")) << endl;
cout << Equal(1,2) << endl;
cout << Equal(1.2,1.21) << endl;
cout << Equal(string("abcd"),string("abc")) << endl;
cout << Equal(1.2,(10.2-9)) << endl;
int arr[] = {1,2,3,1};
cout << Equal(arr,arr+3) << endl; // bool Equal(int*,int*)
cout << Equal("abc","abcd") << endl;
}
