【C++——— 模板进阶】

---

一、非类型模板参数

模板参数分类类型形参与非类型形参。

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

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

我们来看以下代码：

namespace bite
{
 // 定义一个模板类型的静态数组
 template<class T, size_t N = 10>//注意非类型模板参数在c++11之前只支持整形
 class array
 {
 public:
 
 T& operator[](size_t index)
 {	
 	return _array[index];
 }
 const T& operator[](size_t index) const
 {
 	return _array[index];
 }
 
 size_t size() const
 {
 	return _size;
 }
 bool empty() const
 {
 	return 0 == _size;
 }
 
 private:
 T _array[N];
 size_t _size;
 }；
}

模板参数不能是变量，因为模板要在编译时确定实例化出什么类型 ！！

二、模板特化

1.函数模板特化

函数模板的特化步骤：

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

我们来看以下函数模板例子

template<class T>
bool Less(const T& t1,const T& t2)
{
	return t1 < t2;
}

//对Less函数模板特化
template<>
bool Less<Date*>(const Date* d1,const Date* d2)
{
	return *d1 < *d2;
}

2. 类模板特化

1）全特化

将类模板中所有参数都确定化

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

//全特化
template<>
class Data<int, char>
{
public:
 	Data() {cout<<"Data<int, char>" <<endl;}
private:
 	int _d1;
 	char _d2;
};
void TestVector()
{
 	Data<int, int> d1;
	Data<int, char> d2;
}

2）偏特化

//将Date类模板进行偏特化
template<class T1, class T2>
class Data
{
public:
 	Data() {cout<<"Data<T1, T2>" <<endl;}
private:
 	T1 _d1;
 	T2 _d2;
};

//第一种特化
//部分特化
//将模板中部分参数特化

//将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
 	Data() {cout<<"Data<T1, int>" <<endl;}
private:
 	T1 _d1;
 	int _d2;
};

//第二种特化
//参数更进一步的限制
//偏特化并不仅仅是指特化部分参数，
//而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{ 
public:
 	Data() {cout<<"Data<T1*, T2*>" <<endl;}
 
private:
 	T1 _d1;
 	T2 _d2;
};
//两个参数偏特化为引用类型
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 test2 () 
{
 	Data<double , int> d1; // 调用特化的int版本
 	Data<int , double> d2; // 调用基础的模板 
 	Data<int *, int*> d3; // 调用特化的指针版本
 	Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

三、模板分离编译

1.什么是分离编译

模板分离编译：是指将模板的声明和定义分别放在不同的文件中，然后在需要使用模板的源文件中包含相应的声明，并在链接时将模板的定义与使用处进行链接。这样做的目的是为了减少编译时间和避免模板的多次实例化。

2.模板分离编译

// a.h
 template<class T>
 T Add(const T& left, const T& right);
 
 // a.cpp
 template<class T>
 T Add(const T& left, const T& right)
 {
	 return left + right;
 }
 
 // main.cpp
 #include"a.h"
 
 int main()
 {
 	Add(1, 2);
 	Add(1.0, 2.0);
	 return 0;
 }

分析：

3. 解决办法

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

四、模板总结

优点：

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

缺陷：

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