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

注意的是：

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

2.模板的特化

模板的特化分为两种：

1. 函数模板特化
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;
}

运行结果为：

类模板的特化（特化的前提是得 有原模板）来说分为：

1. 全特化：
   从上方也能看出方法为：
   
   也就是将特化的类型写在类名旁边进行特化操作
2. 偏特化
   特化一部分初参数类型，还剩一部分类型仍然为模板参数
   方法为：
   
   同样也就是将特化的类型写在类名旁边进行特化操作，而对于不想特化的就仍然写成模板参数。
   注意如果有歧义那么编译器会找最匹配的（如全特化和偏特化同时有部分特化相等，当全特化更加匹配时那么就会走全特化，具体如下面这种情况那么就会走到全特化 ）
   

此处上面的例子就是全特化更加匹配：

全特化**√** ：

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

1. 此处当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;
};

2. 此处当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函数主要是因为模板的原因，那为什么会加上模板就不行了嘞？？

编译器编译的步骤是：

1. 预处理（展开头文件、替换宏、条件编译） test.i
2. 编译（检查语法、生成汇编）test.s
3. 汇编（将汇编代码转换为二进制机器码）test.o
4. 链接 （将多个.o的目标文件合并）a.out

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

解决方案：

1. 显示实例化：意思就如名字一样进行对应所需的实例化告诉编译器类型如下：但缺点也很明显，当类型变成其他时就需要再写一个 (template double Add < double > ... )
2. 把分离编译的模板函数的实现和声明一起写在同一个头文件里（有些地方会把.h 改成 .hpp），这样当预处理时就会把实现也带进main.cpp中当Add编译时就会找到实现，那么就会直接进行实例化生成地址，不再依赖于链接

4.模板的缺点

1. 导致代码膨胀问题，同时会导致编译时间变长
2. 模板出现编译错误时，错误信息非常难看（方法：先看第一个错误），定位不准

5.适配器

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

而适配器的位置常常是写在模板参数处的

基本的使用方法：创建对象后直接使用该对象即可！

如：插入数据

6.仿函数

仿函数：一种类似于函数的类

仿函数的创建，创建一个类，然后在类中重载operator()

仿函数的使用：通过对象调用operator() ，达到模仿函数的样子去使用（本质还是调用了类中的运算符重载函数）。

1. 构建成对象，通过实例化对象后用对象来使用（见上 图标注1），
   1.1传递给某写函数当函数参数（类似于函数指针！）（如下改变sort的第三个参数就会有不同的效果，实际上把对象传过去在该函数中使用这个仿函数）less排升序(此处模拟实现less(Less))greater排降序
   
   2.当成模板参数传给某类，在类内部通过实例化对象后再直接使用
   具体如下：
   

总结来说仿函数就是一个类似于函数的类，我们只需要将其实例化对象后==通过对象()==就能使用这个仿函数

本章完。预知后事如何，暂听下回分解。

如果有任何问题欢迎讨论哈！

如果觉得这篇文章对你有所帮助的话点点赞吧！

持续更新大量C++细致内容，早关注不迷路，我们下章再会。

​