【C++】模板（二）

本文要点：

非类型模板参数

类模板的特化

模板的分离编译

1.非类型模板参数

模板参数分为类型形参 与非类型形参。

类型形参：出现在模板参数列表中，跟在class或typename之类的参数类型名称。

非类型参数，就是用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用。
C++ 复制代码
template<class T,size_t N = 10>
class array
{
public:
    T& operator[](size_t index){return _array[index];}
    const T& operator[](size_t index)const {return _array[index];}
    
    size_t size()const {return _size};
    bool empty()const {return 0 == _size;}
private:
    T _array[N];
    size_t _size;
};
注意：

浮点数 、类对象 以及字符串是不允许作为非类型模板参数的。

非类型的模板参数必须在编译期就能确认结果。

2.模板的特化

2.1概念

通常情况下，使用模板可以实现一些与类型无关的代码，但是对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。即：在原模板类的基础上，针对特殊类型进行特殊化的实现方式 。模板特化分为函数模板特化 与类模板特化。

2.2函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板；

关键字template后面接一对空的尖括号<>；

函数名跟一对尖括号，尖括号中指定需要特化的类型；

函数形参表：必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
C++ 复制代码
//函数模板
template<class T>
bool Less(T left,T right)
{
    return left < right;
}

//对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left,Date* right)
{
    return *left < *right;
}
注意：一般情况下，如果函数模板遇到不能处理或处理有误的类型，为了实现简单通常都是将该函数直接给出来。

2.3类模板特化

2.3.1全特化

全特化即是将模板参数列表中所有的参数都确定化。

c++ 复制代码

template<class T1,class T2>
class Data
{
public:
    Data(){std::cout<<"Data<T1,T2>"<<std::endl;}
private:
    T1 _d1;
    T2 _d2;
};


template<>
class Data<int,char>
{
public:
    Data(){std::cout<<"Data<int,char>"<<std::endl;}
private:
    int _d1;
    char _d2;
};

2.3.2 偏特化

偏特化：任何针对模板参数进一步进行条件限制设计的特化版本。
C++ 复制代码
template<class T1,class T2>
class Data
{
public:
    Data(){std::cout<<"Data<T1,T2>"std::endl;}
private:
    T1 _d1;
    T2 _d2;
};
偏特化的两种表现方式：

部分特化：将模板参数类表中的一部分参数特化。
c++ 复制代码
//将第二个参数特化为int
template<class T>
class Data<T,int>
{
public:
    Data(){std::cout<<"Data<T,int>"<<std::endl;}
private:
    T1 _d1;
    int _d2;
};
参数更进一步的限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制设计出来的一个特化版本。
C++ 复制代码
//两个参数偏特化为指针类型
template<class T1,class T2>
class Data<T1*,T2*>
{
public:
    Data(){std::cout<<"Data<T1*,T2*>"<<std::endl;}
private:
    T1 _d1;
    T2 _d2;
};

//两个参数偏特化为引用类型
template<class T1,class T2>
class Data<T1&,T2&>
{
public:
    Data(const T1& d1,const T2& d2)
        :_d1(d1)
        ,_d2(d2)
    {
        std::cout<<"Data<T1&,T2&>"<<std::endl;
    }
    
private:
    const T1& _d1;
    const T2& _d2;
};

2.3.3类模板特化应用

如下按照小于比较的类模板Less

c++ 复制代码

#include<vector>
#include<algorithm>

template<class T>
struct Less
{
    bool operator()(const T& x,const T& y)
    {
        return x < y;
    }
};

int main()
{
    Date d1(2022,7,7);
    Date d2(2022,7,6);
    Date d3(2022,7,8);
    
    vector<Date> v1;
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);
    //可以直接排序，结果是日期升序
    sort(v1.begin(),v1.end(),Less<Date>());
    
    vector<Date*> v2;
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);
    //可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
    //此处需要在排序过程中，让sort比较v2中放地址指向的日期对象
    //但是走Less模板，sort在排序时实际比较是v2中指针的地址，因此无法达到预期
    sort(v2.begin(),v2.end(),Less<Date*>());
    
    return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果正确；但如果待排序元素是指针，结果就不一定正确。因为:sort最终按照Less模板中方式进行比较，所以只会比较指针，而不是比较指针所指向空间中的内容，此时可以使用类模板特化来处理上述问题。

c++ 复制代码

//对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{
	bool operator()(Date* x,Date* y)const
    {
        return *x < *y;
    }
};

特化之后，运行上述代码，就可以得到正确的结果。

3.模板分离编译

3.1什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有的目标文件链接起来形成单一的可执行文件的过程被称为分离编译模式。

3.2模板的分离编译

当模板的声明和定义分离时，在头文件中进行声明，源文件中进行定义
C++ 复制代码
//a.h
template<class T>
T Add(const T& left,const T& right);

//a.cpp
template<class T>
T Add(const T& left,const T& right)
{
    return left+right;
}

//main.cpp
#include"a.h"
int main()
{
    Add(1,2);
    Add(1.0,2.0);
    
    return 0;
}
C/C++程序要运行，一般需要经历预处理、编译、汇编、链接。

编译：对程序按照语言特性进行语法、词法、语句分析，错误检查无误后生成汇编代码。注意：头文件不能参与编译，编译器对工程中的多个源文件是分离开单独编译的。

链接：将多个obj文件合并成一个，并处理没解决的地址问题。

3.3解决方法

将声明和定义放到一个文件"xxx.hpp"里，或者"xxx.h"也行。

模板定义的位置显示实例化。不推荐这种方式。

4.模板总结

优点：

模板复用了代码，节省资源，更快地迭代开发，C++的标准库(STL)因此而产生。

增强了代码的灵活性。

缺点：

模板会导致代码膨胀问题，也会导致编译时间变长。

出现模板编译错误时，错误信息非常凌乱，不易定位错误。