【C++】模板

目录

泛型编程

函数模板

函数模板

函数模板的实例化 

模板参数的匹配原则

类模板

非类型模板参数

模板的特化

函数模板特化

类模板特化 

模板分离编译

模板总结

---

泛型编程

泛型编程的引入源自于类似下面这样的案例：

如何实现一个通用的交换函数？

用我们已经掌握的知识，可以使用函数重载来实现：

但是使用函数重载实现有其弊端：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数

2. 代码的可维护性比较低，一个出错可能所有的重载均出错

由此我们想到是否可以使用一个模具， 通过给这个模具中 填充不同材料 ( 类型 ) ，来 获得不同材料的铸件 ( 即生成具体类型的代码）

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

函数模板

函数模板

函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定 类型版本。

函数模板格式

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名 ( 参数列表 ){}

注意： typename 是 用来定义模板参数 关键字 ， 也可以使用 class( 切记：不能使用 struct 代替 class)

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段 ，对于模板函数的使用， 编译器需要根据传入的实参类型来推演生成对应类型的函数 以供调用。比如：当用 double 类型使用函数模板时，编译器通过对实参类型的推演，将 T 确定为 double 类型，然 后产生一份专门处理 double 类型的代码 ，对于字符类型也是如此。

通过观察不难发现这里调用的函数不同，因为这里的函数是编译器根据传的类型将函数模板实例化得到的函数，因此不是同一个函数。

函数模板的实例化 

用不同类型的参数使用函数模板时 ，称为函数模板的 实例化 。模板参数实例化分为： 隐式实例化和显式实例 化 。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

通过上图汇编代码可以发现编译器根据传的参数类型生成了对应的函数，但是如果写成这样： Add(a1, d1); 

就不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错。

那么这里的解决方式有两种：

  1.用户自己强制转化： Add ( a1 , ( int ) d1 );

  2.使用显示实例化

2. 显式实例化：在函数名后的 <> 中指定模板参数的实际类型

     Add < int > ( a1 , d1 );

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函 数

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模 板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

类模板

类模板的定义格式

template<class T1, class T2, ..., class Tn>

class 类模板名

{

        // 类内成员定义

};

类模板的应用场景，我们以栈举例：

这是一个简单的栈，我们发现这个栈我们通过控制开始的DataType就可以实现不同类型的栈，也相当于是泛型编程，但是在一种场景下这里修改DataType就失效了，如果我要在一个项目里同时建立两个栈，一个int，一个double，那么就做不到了，因此引入类模板。

注意：Stack不是具体的类，是编译器根据被实例化的类型生成具体类的模具

类模板实例化与函数模板实例化不同， 类模板实例化需要在类模板名字后跟 <> ，然后将实例化的类型放在 <> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

Stack是类名，Stack<int>才是类型

类模板中函数放在类外进行定义时，需要加模板参数列表

在模板中，typename和class一般没有区别，但是在下面的场景中，二者存在区别：

我们首先写了一个针对于vector<int>的Print函数，使用没有问题：

接下来我们要写一个针对各种类型的Print函数，这里的各种类型可以是vector<double>，也可以是别的容器list<int>

这里这样写是编译不通过的：

解决方法如下：

这里之前之所以编译不通过 是因为Container没有实例化，编译器在编译过程中要对Container::const_iterator it = v.begin();  这段代码进行初步检查，但是由于没有实例化所以编译器不清楚这里的Container是什么，那么这里就出现两种情况，这个const_iterator可以是一个静态成员或对象，也有可能是一个内部类，也就是说这个东西可以是个对象，也可以是个类型，如果是类型符合语法，但如果是对象则不符合语法，因此编译器无法判断，所以加一个typename就是为了告诉编译器这是一个类型，等模板实例化再去找。

当然这里直接写成auto更简洁：

非类型模板参数

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

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

非类型形参，就是用一个常量作为类 ( 函数 ) 模板的一个参数，在类 ( 函数 ) 模板中可将该参数当成常量来使用。

下面是一个非类型模板参数的使用场景：

创建静态栈，我们可以像下面这样创建

那么问题来了，这里的st1和st2都是可以存10个元素的栈，如果我的需求是st1存10

个，st2存100个呢？

因此，基于这样的场景，我们引入非类型模板参数：

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的(只能是整型) 。

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

模板的特化

通常情况下， 使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结 果 ，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

可以看到， Less 绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中， pa 指向的a 显然大于 pb 指向的b ，但是 Less 内部并没有比较 p1 和 p2 指向的内容，而比较的是 p1 和 p2 指针的地址，这就无法达到预期而错误。

此时，就 需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式 。

函数模板特化

函数模板的特化步骤：

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

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

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

4. 函数形参表 :  必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

当然， 一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给 出，构成函数重载：

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。

类模板特化 

全特化

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

偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

1.部分特化 ：将模板参数类表中的一部分参数特化

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
 Data() {cout<<"Data<T1, int>" <<endl;}
private:
 T1 _d1;
 int _d2;
};

2.参数更进一步的限制 ：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{ 
public:
    Data() {cout<<"Data<T1*, T2*>" <<endl;}
 
private:
    T1 _d1;
    T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
    Data(const T1& d1, const T2& d2)
     : _d1(d1)
     , _d2(d2)
    {
       cout<<"Data<T1&, T2&>" <<endl;
    }
 
private:
    const T1 & _d1;
    const T2 & _d2;
 };
void test () 
{
     Data<double , int> d1; // 调用特化的int版本
     Data<int , double> d2; // 调用基础的模板 
     Data<int *, int*> d3; // 调用特化的指针版本
     Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

模板分离编译

模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义会引发链接错误。原因是某个类的函数声明在a.h，定义在a.cpp，使用在main.cpp中，那么编译时这三个文件是分离开单独编译的，编译汇编过程结束后，两个cpp文件生成两个obj文件，然后开始链接成一个，并处理没有解决的地址问题。在a.cpp文件中，编译器没有找到模板函数的实例化，因此不会产生具体的函数，在main.obj文件中调用了该函数，编译器只有在链接时才会找该函数的地址，但是该函数没有实例化，没有生成具体的代码，因此会链接出错。

解决方法

1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者 xxx.h 其实也是可以的 。(推荐使用这种)

2. 模板定义的位置显式实例化。 这种方法不实用，不推荐使用。

     显式实例化格式：

        template

        class 类名<类型>

模板总结

【优点】

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

2. 增强了代码的灵活性

【缺陷】

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

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