C++---模板进阶（非类型模板参数，模板的特化，模板分离编译）

我们都学习和使用过模板，而这篇文章我们来将一些更深入的知识。在此之前，我们在使用C++编程时可以看到模板是随处可见的，它能支持泛型编程。模板包括函数模板和类模板，我们有的人可能会说是模板函数和模板类，但严格讲这样说是错误的。而在我们实际使用中，类模板用的场景是比函数模板多的，如STL中vector，list等都是类模板，而算法中sort，find等是函数模板。

非类型模板参数

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

类型形参：出现在模板参数列表中，跟在class或typename关键字之后的参数类型名称。（我们之前一直使用的）

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

举个例子：

我们想要创建一个大小固定，可以存储不同类型元素的数组类，我们可以这样写：

#include<iostream>
using namespace std;
#define N 10

template<class T>
class Array
{
private:
	int _a[N];	
};
int main()
{
	Array<int> arr1;
	Array<int> arr2;
	return 0;
}

这时实例化出来的arr1，arr2都是大小为10的定长数组。但我们假如说想改变一个数组的长度呢？例如我们想将数组长度改为20，怎么办呢？有同学说我们可以将N define为20呀。但是假如我们想要一个数组长为10，另一个长为20呢？

这时候我们的非类型模板参数就有作用了，我们可以将Array定义为下面的形式：

#include<iostream>
using namespace std;

//这里的N叫做非类型模板参数,它是一个常量 
template<class T, size_t N>
class Array
{
private:
	int _a[N];
};
int main()
{
	Array<int, 10> arr1;
	Array<int, 20> arr2;
	int n = 10;
	Array<int, n> arr3;//error 这里非类型模板参数是常量，这里会报错
	return 0;
}

对于非类型模板参数的使用场景，STL中的deque和array容器中都用了。deque中的非类型模板参数用来传一个一个常量来控制buff的大小。

我们下面介绍一下array容器：

C++11支持array，它的结构类似于vector，只不过vector是动态数组，而array是静态的。它不提供头插，头插，尾插，尾删，任意位置插入删除这种操作，因为它根本不存在这种说法，而且它可以直接使用operator[ ] 访问修改任意位置的数据。

array的缺陷：

我们不推荐使用array，array底层是在栈上开辟空间的，而栈空间又是很有限的，例如：在32位的linux下栈空间只有8M，所以一般开大空间时极不推荐使用array，相比之下vector就很有优势。而且在知道要开多大空间的情况下，vector 也可以通过reserve一次性开好空间，在后续的使用中还可以自动增容，而array空间是固定的，不灵活。所以我们一般不使用array。

注意：

非类型模板参数只允许使用整形家族（int，short，long，long long，char），而浮点型，类对象，字符串是不允许作为非类型模板参数的
非类型模板参数需要在编译的时候就确认结果，因为编译器在编译阶段就需要根据传入的非类型模板参数生成对应的类或函数

模板的特化

我们先举个例子，理解一下模板的特化，看下面的代码：

template<class T>
bool IsEqual(const T& left, const T& right)
{	
	return left == right;
}
int main()
{
	cout << IsEqual(1, 2) << endl;
	char p1[] = "hello";
	char p2[] = "world";
	cout << IsEqual(p1, p2) << endl;
	return 0; 
}

我们实现了IsEqual函数用来判断两个参数是否相等。我们总共调用了两次，第一次比较的是两个整数，是没问题的；而第二次实际上是有问题的，我们本意是想比较两个字符串是否相等，可是我们仔细看看：我们实际上比较的p1，p2两个指针。我们可能会想先判断一下传过来的参数的类型是什么，再进行不同的操作，就像下面这样：

template<class T>
bool IsEqual(const T& left, const T& right)
{
	if(T == char*)//error,C++中不支持类型比较
	{
        return *left==*right;
    }
	else
	{...}
	
	return left == right;
}
int main()
{
	cout << IsEqual(1, 2) << endl;//ok
	char* p1 = "hello";
	char* p2 = "world";
	cout << IsEqual(p1, p2) << endl;//err
	return 0; 
}

但是很可惜，C++中不支持类型比较，所以上面写的是错误的。

那么这里就需要我们的模板特化出手了，模板特化的目的就是在原模板类的基础上，针对某些类型进行特殊化处理。模板特化又分为函数模板特化和类模板特化。

函数模板的特化

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

我们上面的代码就可以改为：

#include<iostream>
using namespace std;

template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}

template<>
bool IsEqual<const char *&>(const char*& left,const char*& right)
{
	return strcmp(left, right)==0;
}
int main()
{
	cout << IsEqual(1, 2) << endl;
	const char* p1 = "hello";
	const char* p2 = "hello";
	cout << IsEqual(p1, p2) << endl;
	return 0;
}

说明：其实一般情况下，如果函数模板遇到不能处理或者处理有误的类型，可以直接将该函数直接给出，这叫做模板的匹配原则：有现成的完全匹配的，就直接调用，没有现成调用的，实例化模板生成。上面的代码就可以这样写：

#include<iostream>
using namespace std;

template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}

bool IsEqual(const char*& left,const char*& right)
{
	return strcmp(left, right)==0;
}
int main()
{
	cout << IsEqual(1, 2) << endl;
	const char* p1 = "hello";
	const char* p2 = "hello";
	cout << IsEqual(p1, p2) << endl;
	return 0;
}

对于模板匹配原则和函数模板特化，两者底层没有任何差别，如果能使用函数模板特化的时候更推荐使用函数模板特化。

类模板特化

1.全特化

就是将模板参数列表中所有参数确定化，例如：

#include<iostream>
using namespace std;

template<class T1,class T2>
class A
{
public:
	A()
	{
		cout << "T" << endl;
	}
private:
	T1 a1;
	T2 a2;
};

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

int main()
{
	A<double, double>a1;
	A<int, int>a2;
	return 0;
}

2.偏特化

也叫半特化：即对模板参数进行一定的确定化，例如：

template<class T1>//第二个参数是int类型就会调用这个
class A<T1, int>
{
public:
	A()
	{
		cout << "T1,int" << endl;
	}
private:
};

template<class T2>//第一个参数是int类型就会调用这个
class A<int, T2>
{
public:
	A()
	{
		cout << "int,T2" << endl;
	}
private:
};

template<class T1,class T2>//两个参数都是指针类型就会调用这个
class A<T1*, T2*>
{
public:
	A()
	{
		cout << "T1*,T2*" << endl;
	}
private:
};

template<class T1, class T2>//两个参数都是引用类型就会调用这个
class A<T1&, T2&>
{
public:
	A()
	{
		cout << "T1&,T2&" << endl;
	}
private:
};

template<class T1, class T2>//第一个参数是指针类型，第二个参数是引用类型就会调用这个
class A<T1*, T2&>
{
public:
	A()
	{
		cout << "T1*,T2&" << endl;
	}
private:
};

int main()
{
	A<double, int>a;
	A<int, char>b;
	A<double*, int*>c;
	A<char&, int&>d;
	A<double*, char&>e;

	return 0;
}

上面这几种特化版本都是偏特化。

偏特化并不仅仅是指特化，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本，例如我们可以限制他的类型是引用，指针之类的。

关于特化的场景我们等到哈希表的时候会给大家介绍。

模板分离编译

我们在工作的时候写的项目都会由若干个源文件共同实现，每个源文件独立编译生成目标文件，最后将所有目标我呢见链接起来形成单一的可执行文件的过程称为分离编译模式。

模板的分离编译

在前面我们模拟实现string，vector，list等STL容器的时候，都没有将声明和定义分开。我们实际上是习惯将声明放在头文件中，将定义放在.cpp文件中的。我们没有分离的原因就是C++的模板不支持分离编译。

我们以这段代码为例：

//Func.h代码:
#pragma once
#include<iostream>
using namespace std;

void Print();

template<class T>
void F(T a);

//Func.cpp代码
#include"Func.h"

void Print()
{
	cout << "print" << endl;
}

template<class T>
void F(T a)
{
	cout << "F(T a)" << endl;
}

//test.cpp代码
#include"Func.h"

int main()
{
	Print();
	F(10);//这里编不过
	return 0;
}

不支持分离编译的原因：
我们都知道：程序的编译过程分为：预处理，编译，汇编，链接四个步骤

其中预处理会做的事情就是：头文件展开，宏替换，条件编译，去掉注释，在linux环境下就生成了.i文件

编译：检查语法错误后，生成汇编代码，在linux环境下生成.s文件