一、模版参数

模板参数分为：类型参数 和 非类型参数

1、类型参数

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

比如下面的，模板类型参数：T

template<class T>
void swap(T& x, T& y)
{T tmp = x;x = y;y = tmp;
}

2、非类型参数

（1）用一个常量作为一个类或者函数模板的一个参数，在类或者函数模板中把这个参数当作常量来使用。比如下面代码中的N就是：非类型的模板参数

// 非类型模板参数
template<class T ,size_t N>
class Car
{
private:T _arr[N];
};int main()
{Car<int, 20> c1;// N=20Car<int, 40> c2;// N=40return 0;
}

（2）对于函数模板也可以给缺省值，给缺省值的规则跟之前讲的类和对象的规则一样。只能从后往前给，按顺序不能跳着给。

// 非类型模板参数
template<class T=int ,size_t N=30>
class Car
{
private:T _arr[N];
};int main()
{Car<int, 20> c1;// N=20Car<int, 40> c2;// N=40Car<> c3;// 这里没有实例化模板，使用了模板默认的缺省值！return 0;
}

注意：

1、目前来看非类型模板参数只支持整型，不支持浮点型和字符型：

template<class T,double N>

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

// 非类型模板参数
template<class T , size_t N>//template<class T,double N>
class Car
{
private:T _arr[N];
};int main()
{Car<int> c1;// N(非类型模板参数)必须在编译时期就确认好结果！return 0;
}

二、模板的特化

什么叫：模板的特化？

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

template<class T>// 函数模板
bool Less(T left, T right)
{return left < right;
}int main()
{cout << Less(1, 3) << endl;// 比较结果正确Date d1(2024, 4, 1);Date d2(2024, 5, 1);cout << Less(d1, d2) << endl;// 比较结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl;// 比较结果，错误！！！return 0;
}

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

此时我们就要对模板进行特化，模板的特化就是：在原有模板的基础上，对特殊类型进行特殊处理。
模板的特化分为：函数模板特化 和 类模板特化。

1、函数模板的特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}int main()
{cout << Less(1, 2) << endl;Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl;Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了return 0;
}

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

bool Less(Date* left, Date* right)
{return *left < *right;
}

2、类模板特化

类模板在没有特化之前，调用的都是原模板，如下代码：

#include<iostream>
using namespace std;//类模板
template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1,T2>" << endl;}
};void Test_Class()
{Data<int, int> d1;Data<int, char> d2;
}int main()
{return 0;
}

类模板分为全特化和偏特化，但是类模板只有一种写法，没有简写形式

（1）全特化

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

比如想把T1指定成int，T2指定成char

template<class T1, class T2>
class Date
{
private:T1 _d1;T2 _d2;
public:Date(){cout << "Date<T1,T2>" << endl;}};// 全特化：将类模板，里面的所有参数列表，都确定化！
template<>
class Date<int,char>
{
private:int _d1;char _d2;
public:Date(){cout << "Date<int,char>" << endl;}
};void Test_Date()
{Date<int, int> d1;// 创建d1的时候，走的是第1个类模板！Date<int, char> d2;// 创建d2的时候，走的是第2个类模板！(因为特化后的模板类型就是：int,char，正好跟d2对接！有现成的就吃现成的！)
}int main()
{Test_Date();return 0;
}

（1）创建d1的时候，走的是第1个类模板！
（2）创建d2的时候，走的是第2个类模板！(因为特化后的模板类型就是：int,char，正好跟d2对接！有现成的就吃现成的！)

（2）偏特化

偏特化是任何针对模板参数进一步进行条件限制的特化版本。偏特化分为两种表现方式：

①部分特化：把模板参数类表中的一部分参数特化

// 偏特化:部分特化
template<class T1>
class Date<T1, double>
{
private:T1 _d1;double _d2;
public:Date(){cout << "Date<T1,double>" << endl;}
};void Test_Date()
{Date<int, int> d1;// 创建d1的时候，走的是第1个类模板！Date<int, double> d2;// 创建d2的时候，走的是第2个类模板！
}int main()
{Test_Date();return 0;
}

②对参数进一步限制：对模板参数做更进一步的条件限制

可以将参数偏特化为指针类型 ：

//偏特化-两个参数偏特化为指针类型，只指定指针，什么类型的指针都可以
template<typename T1,typename T2>
class Data<T1*, T2*>
{
public:Data(){cout << "Data<T1*,T2*>" << endl;}
private:T1 _d1;T2 _d2;
};

void Test_Class()
{Data<int, int> d1;Data<int, double> d2;Data<int, char> d3;Data<char*, char*> d4;//会调用两个参数偏特化为指针类型的偏特化
}

也可以将参数偏特化为引用类型：

//偏特化-两个参数偏特化为引用类型，只指定引用，什么类型的引用都可以
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_Class()
{Data<int, int> d1;Data<int, double> d2;Data<int, char> d3;Data<char*, char*> d4;//会调用两个参数偏特化为指针类型的偏特化Data<double&, double&> d5(2.1, 3.2);//会调用两个参数偏特化为引用类型的偏特化
}

三、模板分离编译

什么是分离编译？

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

1、模板支持分离编译吗？

对于分离式编译的模板:
template.h：

template<class T>
T Add(const T& left, const T& right);

template.cpp ：

#include "template.h"template<class T>
T Add(const T& left, const T& right)
{return left + right;
}

template-main.cpp：

#include "template.h"int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

上述代码运会报错！

2、为什么模板不支持分离编译？

3、如何编译模板文件？

（1）显示指定实例化

（2）推荐：将声明和定义放在同一个文件

解决方法：

1. 将声明和定义放到一个文件 “xxx.hpp” 里面或者xxx.h其实也是可以的。推荐使用这种。
2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

四、总结

【优点】
1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性

【缺陷】
1. 模板会导致代码膨胀问题，也会导致编译时间变长
3. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！