C++基础7：模板编程/泛型编程

1、基本概念

1.1 什么是模板？

模板（Template）是允许函数或者类通过泛型（generic types）的形式表现或运行的特性

1.2 模板有什么用？

模板可以使函数或者类只写一份代码而对应不同的类型

1.3 模板编程/泛型编程

一种独立于特定类型的编码方式

1.4 模板分类

模板分为函数模板与类模板两类
（1）函数模板（Function template）：使用泛型参数的函数（function with generic parameters）
（2）类模板（Class template）：使用泛型参数的类（class with generic parameters）

2、函数模板

2.1 模板声明

template <模板形参表> 函数返回类型 函数(形参表);

2.2 模板定义

template <模板形参表>
函数返回类型 函数(形参表){
      函数体;
};

2.3 例子及模板实例化

例子：

template <typename T> T Max(T a,T b){
        return a>b?a:b;
}

模板实例化：

函数(实参表)

产生模板特定类型的函数或者类的过程称为实例化
调用函数模板与调用函数完全一致
实例：
最值函数Max(),Min()
字符串转数值Ston()

3、类模板

3.1 模板声明

template <模板形参表> class 类名;

3.2 模板定义

template <模板形参表>
class 类名 {
}

3.3 模板实例化

类名<模板实参表> 对象;

3.4 模板参数等

1、模板参数表
多个模板参数之间,分割。模板参数,模板参数,…
2、模板参数
3、类型形参
class 类型形参或者typename 类型形参
类模板的声明与实现通常都写在头文件中，是不能够分开的。

3.5 实例

复数类Complex
三角形类Triangle

4、模板参数推导/推演（deduction）

模板参数推导/推演(deduction):由模板实参类型确定模板形参的过程。

实例化有两类：
显示实例化：代码中明确指定类型的实例化
隐式初始化：根据参数类型自动匹配的实例化
类模板参数允许自动类型转换(隐式转换);函数模板参数不允许自动类型转换(隐式转换)
在模板参数列表中，class和typename完全一样。但是在语义上，class表示类，typename代表所有类型(类以及基本类型)。
请尽量使用typename

模板实例化时：

Max(2,2.4)

参数推导会出现模板实参类型int与double不一致的错误。
解决方法：

1、每个模板参数独立类型

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;
}

2、显示指定模板实参类型

Max<int>(2,2.4)

或者

Max<double>(2,2.4)

3、实参强制类型转换

Max(2,static_cast<int>(2.4))

或者

Max(static_cast<double>(2),2.4)

模板参数推导不允许类型自动转换，模板参数必须严格匹配。
函数模板实例显示指定模板实参可以显示指定模板实参，也可以不指定(类型自动推导)，类模板实例化必须

5、特化

模板特化(specialization):模板参数在某种特定类型下的具体实现称为模板的特化。模板特化有时也称之为模板的具体化。
特化作用

1、对于某种特殊类型，可以做特殊处理或者优化。
2、避免实例化类的时候产生诡异行为。
模板特化分类

1、函数模板特化(Function specializations)：对函数模板的全部模板类型指定具体类型。
2、类模板特化(Class specializations)：对类模板的全部或者部分模板类型指定具体类型。

5.1 函数模板特化

特点：函数模板，却只有全特化，不能偏特化。
步骤：与类的全特化相同
示例：

template<typename T>
void Func(const T& n){}

// 特化
template<>
void Func(const int& n){}

5.2 类模板特化

特点：类模板特化，每个成员函数必须重新定义。

类模板特化分为两种

1、全特化(Full specializations)：具体指定模板的全部模板参数的类型。
2、局部特化(Partial specializations)：具体指定模板的部分模板参数的类型。

5.2.1 全特化

步骤：

1、声明一个模板空参数列表template<>
2、在类名称后面的<>中显示指定类型。
示例：

// 模板  
template<class T>
class Test{};

// 全特化
template<>
class Test<int*>{};

5.2.2 偏特化

偏特化就是部分特化，分为两种情况

1、个数特化：只为部分模板参数指定具体类型(模板参数个数变少)
2、范围特化：模板参数不变，限制模板参数的匹配类型(指针、引用、const)
步骤：

1、在一个模板类参数列表不指定或者指定部分具体类型。
2、在类名称后面的对应类型中显示指定该类型。
示例：

template<typename T1,typename T2>
class Test{};

（1）将模板参数偏特化为相同类型

template<typename T>
class Test<T,T>{};

（2）将一个模板参数特化成具体类型

template<typename T>
class Test<T,int>{};

（3）把两个类型偏特化成指针类型

template<typename T1,typename T2>
class Test<T1*,T2*>{};

实例：三元组模版Triple
类模板特化，相当于函数模板的重载

全特化和偏特化的编码区别：
全特化的模板参数列表为空template<>，偏特化的模板参数列表不为空。

6、模板原理

模板通常会被编译两次

1、实例化前，检查模板代码是否有语法错误。
2、实例化中，检查模板代码调用是否合法。

7、类模板

成员函数：只有调用时才会被实例化。
静态成员：每次类模板实例化，都会被实例化。

类实例化成对象，类模板实例化成类。

类模板：不完整的类，一个或者多个成员类型未确定。
函数模板：不完整的函数，一个或者多个参数类型未确定。

8、实例：

函数模板重载和特化

#include 
#include 

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;
    cout <<Equal("abc","abcd") << endl;
}

输出结果：

1
1
1
0
0
0
1
1
0