C++模板（2）

非类型模板参数

模板参数分为类型形参和非类型形参
类型形参：出现在模板参数列表中，跟在class或typename之类的参数类型名称后。
非类型形参：用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用。

C++11提供了一个叫array的容器，和vector相似，但vector插入数据不需要考虑空间大小，不够了就扩容。而array是静态数组，是固定大小的，它用了一个非类型模板参数来控制大小。它没有头插头删等操作，而是用方括号[]来给某个位置给值。

//T是类型模板参数；N是非类型模板参数，N是一个常量
template<class T=int, size_t N=10> 
class Array
{
private:
	T _a[N];
};

int main()
{
    Array<> a;//全缺省且用缺省值时这样写
	Array<int, 100000> a1; //400000byte都在栈上

	vector<int> v; //12byte在栈上
	v.resize(100000); //400000byte在堆上

	return 0;
}

这里N给了缺省值。模板参数都可以给缺省值，模板参数给缺省值跟函数参数给缺省值是完全类似的。（全缺省、半缺省）
我们用这些容器通常都是在函数里面定义。array没有扩容，调用函数时建立栈帧，栈一般比较小，如果数据量太大，可能引发栈不够。
而vector，成员变量是3个指针，调用函数时32位下只有12byte在栈上，然后再扩容（在堆上），而堆的空间很大。
C++11增加了4个容器，其中array和forward_list有些鸡肋。
注意：

• 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
• 非类型的模板参数必须在编译期就能确认结果。

模板的特化

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板特化

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

int main()
{
	int x = 1, y = 2;
	Swap(x, y);

	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2 = { 10,20,30,40 };
	Swap(v1, v2);

	return 0;
}

当我们只交换int类型时，没有问题，但交换vector时，要深拷贝3次，代价非常大。针对vector，需要特殊处理一下，以下有两种方法，一种是专项特化，另一种是直接利用模板的匹配原则进行特殊化：

步骤：

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

//函数模板的特化
template<>
void Swap<vector<int>>(vector<int>& v1, vector<int>& v2)
{
	v1.swap(v2);
}

//模板匹配原则，进行特殊化处理
void Swap(vector<int>& v1, vector<int>& v2)
{
	v1.swap(v2);
}

类模板特化

全特化

类模板要处理特殊类型时就不能利用模板匹配原则了。这里假设有一个日期类：

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

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

int main()
{
	Data<int, int> d1;
	Data<double, double> d2;

	return 0;
}

偏特化/半特化

template<class T>
class Data<T, char>
{
public:
	Data() {
		cout << "Data<T,char>" << endl;
	}
};
int main()
{
	Data<double, char> d3;
	Data<int, char> d4;
	
	return 0;
}

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

template<class T1,class T2>
class Data<T1*, T2*>
{
public:
	Data() {
		cout << "Data<T*,T*>" << endl;
	}
};

template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data() {
		cout << "Data<T&,T&>" << endl;
	}
};

template<class T1, class T2>
class Data<T1&, T2*>
{
public:
	Data() {
		cout << "Data<T&,T*>" << endl;
	}
};

int main()
{
	Data<int*, char*> d5;
	Data<int*, int*> d6;
	Data<char&, int&> d7;
	Data<int&, double&> d8;
	Data<int&, double*> d9;

	return 0;
}

模板分离编译

模板不支持分离编译

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

调用F函数时将报错：


链接错误一般是找不到定义，链接时func.o是独立的，但F的实例化在test.o中，在func.o中找没找到，没到合在一起形成可执行程序就报错了。

再如以下例子：

解决方法：

1. 不分离编译，将声明和定义放到一个文件 “xxx.hpp” 里面或者xxx.h

template<class T>
void F(const T& x);

template<class T>
void F(const T& x)
{
    cout << "void F(const T& x)" << endl;
}

类模板：
.h:

template<class T>
class Stack
{
public:
	Stack();
	~Stack();
private:
	T* _a;
	int _top;
	int _capacity;
};

template<class T>
Stack<T>::Stack()
{
	_a = new T[10];
	_top = 0;
	_capacity = 10;
}

template<class T>
Stack<T>::~Stack()
{
	delete[] _a;
	_a = nullptr;
}

2. 模板定义的位置显式实例化。缺陷：用一个类型就得显式实例化一个，非常麻烦

#include "func.h"

template<class T>
void F(const T& x)
{
    cout << "void F(const T& x)" << endl;
}

//显示指定实例化
template
void F(const int& x);

template
void F(const double& x);

注意：模板如果没有实例化，编译器不会去检查模板内部语法语法错误。比如我们实例化了栈这个类，堆类模板是按需实例化，调用了哪个成员函数就实例化谁。但是类的架子会检查，但成员函数中具体内容不会检查。

模板总结

优点：

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

缺点：

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