C++语法---模板进阶知识

绪论
“那些看似不起波澜的日复一日，会在某天让你看到坚持的意义。”本篇文章主要写到非类型的模板参数、模板的特化、模板的分离编译问题、以及适配器和仿函数的使用讲解，在之前已经将模板的基本使用进行了学习（可见c++模板）话不多说安全带系好，发车啦（建议电脑观看）。

思维导图：
在这里插入图片描述
要思维导图的话可以私信喔！

1.非类型模板参数

在模板参数中分为了类型模板参数和非类型模板参数

类型模板参数：出现在模板中在class/typename后的参数类型名称
非类型模板参数：用一个常量作为类的一个模板参数，在类中就能直接使用这个常量

例如，在一个类中成员变量为一个静态数组时，我们可以通过这个常量来控制该数组的大小：

template<class T,size_t N>
class Aarry
{
    
    
private:
	T base[N];
};

int main()
{
    
    
	Aarry<int, 5> a;
	return 0;
}

在这里插入图片描述
注意的是：

该非类型的模板参数支持整形（浮点型不可以，在c++11及以前暂时不能使用）
且只能是常量，而不能为变量

2.模板的特化

模板的特化分为两种：

函数模板特化

类模板特化

使用方法不同通过具体实例来看：

2.1 对于类的特化：

template<class T , class Z>
class A
{
    
    
public:
	A() {
    
     cout << "class A<T,Z>" << endl; }

private:
	T _a;
	Z _z;
};

//注意下方！！！！
//此处就是一个类的**全特化**（所有模板参数都进行了特化）
//方法如下就是在类旁边加上特化的类型
template<>
class A<int,double>
{
    
    
public:
	A() {
    
     cout << "class A<int,double>" << endl; }

private:
	int _a;
	double _z;
};

template<class T1>
class C<T1,double>
{
    
    
public:
	C() {
    
     cout << "class C<T1,double>" << endl; }

private:
	T1 _a;
	double _z;
};

int main()
{
    
    
	A<int,double> a1;//调用特化的类
	A<int,int> a1;//调用特化的类
	A<int*, int*> a2;//正常实例化对象
	
	return 0;
}

运行结果为：在这里插入图片描述
类模板的特化（类模板特化的前提是有原模板）来说分为：

全特化：
从上方也能看出方法为：

将：特化的类型写在类名旁边进行特化操作
此时当模板参数的类型为int和double时将会优先进入该类

偏特化
特化一部分初参数类型，还剩一部分类型仍然为模板参数
方法为：

同样也就是将特化的类型写在类名旁边进行特化操作，而对于不想特化的就仍然写成模板参数。

注意:
如果同时存在多个匹配时那么编译器会自动找最匹配的
如：全特化和偏特化同时有部分特化相等，当全特化更加匹配时那么就会走全特化，具体如下面这种情况那么就会走到全特化在这里插入图片描述
此处上面的例子就是全特化更加匹配：
全特化√：
故不会走到下面这个类：

偏特化的特别使用，对参数的限制

扫描二维码关注公众号，回复： 17268947 查看本文章

当T1、T2是指针类型时会走该特化类：

template <class T1,class T2>
class Date<T1*,T2*>//此处当T1、T2是指针时走这里！！
{
    
    
public:
	Date() {
    
     cout << "Data<T1*, T2*>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

在这里插入图片描述

当T1、T2是引用类型时会走该特化类：

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

在这里插入图片描述

2.2函数模板的特化

函数的特化先见于下面例子：

template<class T>
bool Less(T left, T right)
{
    
    
	return left < right;
}

int main()
{
    
    
	Date* d1 = new Date(2000, 10, 1);
	Date* d2 = new Date(2000, 10, 2);
	
	cout << Less(d1, d2) << endl;
//预计为日期d1 < 日期d2 返回打印1
	return 0;
}

上面程序结果为：
在这里插入图片描述

我们预期的结果是1（日期d1 < 日期d2）,可发现这个结果是不确定的（可能1/0），分析发现这是因为Less函数接收到的T类型为Date*（指针类型）而d1、d2的地址每次分配都不一样可大可小，对此这里我们应该是要取到*d1 与 *d2 进行比较而不是d1 与 d2 比。
所以我们应该对这种情况进行特殊化处理（函数特化）
具体如下：

//特化方法如下：
template<>
bool Less<Date*>(Date* left, Date* right)//当接收到Date*类型时进行特殊化处理
{
    
    
	return *left < *right;//去取日期来比较 而非地址
}

通过上面能看出函数特化的写法：

在有原函数模板的前提下，特化一个函数的方法：
1. 写下template<>
2. 再将特化的类型用尖括号（<>）写到函数名旁边
3. 并且还要改变函数内所用到该类型的类型名

注意的特殊点

此处的const是要修饰变量本身left、right（&left、&right），而不是*left、right 所以把const挪到后面
理解如同： const int * p （修饰指针p）与 int * const p（修饰变量p）

一般来说：
类模板用特化，函数模板不用特化用重载（编译器一般会用最适配的，故有更匹配的重载时，会直接调用该函数）！

3.模板的分离编译问题

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

当有模板的函数进行分离编译时会出现下面问题：

//在 Add.cpp 的函数实现
template<class T>
T Add(const T& t1, const T& t2)
{
    
    
	return t1 + t2;
}
//在 Add.h 头文件中的函数声明
template<class T>
T Add(const T& t1, const T& t2);//类函数的分离编译

//在 main.cpp 中
int main()
{
    
    
	cout << Add(1,2) << endl;
	return 0;
}

在这里插入图片描述
反观普通函数（没有模板的）就能正常跑：

//fun.cpp
void fun()
{
    
    
	cout << "void fun()" << endl;
}
//fun.h
void fun();//普通函数的分离编译

//main.cpp
int main()
{
    
    
	fun();
	//cout << Add(1,2) << endl;
	return 0;
}

在这里插入图片描述
对此发现找不到Add函数主要是因为模板的原因，那为什么会加上模板就不行了嘞？？
编译器编译的步骤是：

预处理（展开头文件、替换宏、条件编译） test.i

编译（检查语法、生成汇编）test.s

汇编（将汇编代码转换为二进制机器码）test.o

链接（将多个.o的目标文件合并）a.out

此处主要是因为对于模板函数来说，他在运行阶段时才会实例化产生地址，因此在编译阶段始终都是没有地址的，而编译时会给Add函数变成汇编指令 call Add(地址) ，一般分离编译的函数在链接时就会通过合并符号表（存放着符号汇总（汇总一些全局变量和函数）的符号）将此处的地址补齐（链接）（此处具体可见博客），而模板函数因没存地址就无法进行补齐，导致出错。

解决方案：

显示实例化：意思就如名字一样进行对应所需的实例化告诉编译器类型如下：但缺点也很明显，当类型变成其他时就需要再写一个 (template double Add < double > … )

把分离编译的模板函数的实现和声明一起写在同一个头文件里（有些地方会把.h 改成 .hpp），这样当预处理时就会把实现也带进main.cpp中当Add编译时就会找到实现，那么就会直接进行实例化生成地址，不再依赖于链接

4.模板的缺点

导致代码膨胀问题，同时会导致编译时间变长

模板出现编译错误时，错误信息非常难看（方法：先看第一个错误），定位不准

5.适配器

适配器是一种设计模式，常用于一些可以套用的结构中，如stack、queue他们底层都需要一个存储数据的容器，而这个容器就能通过适配器来直接调用的来使用，不需要再自行实现。如stack他的适配器就能是vector、list、dequeue。
而适配器的位置常常是写在模板参数处的

基本的使用方法：只要创建了对象后就可以直接使用该对象！

如：插入数据