前言

我们在前几篇的学习中只是使用了最简单的模板，比如用一个模板类等等，我们这篇的学习将在以前的基础上再深入的学习一下模板。

一、非类型模板参数

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

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

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

下面我们来演示一下：

#define N 10
//类型模板参数
template<class T>
class array
{
public:

private:
	T _a[N];
};

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

在以前，我们想要在一个类中定义一个模板数组能实现存放不同个数的数组是不行的，因为我们define的N是一个固定值，如下图：

我们如何让两个数组存放的类型不同存放的个数也不同呢？这个时候非类型模板参数的效果就来了，如下：

//非类型模板参数
template<class T,size_t n = 10>
class Array
{
public:

private:
	T _a[n];
};

int main()
{
	Array<int,5> a1;
	Array<double,8> a2;
	return 0;
}

我们可以看到这两个数组类型不同，数组元素个数也不同。在这里要记住，非类型模板参数一定是整形常量，不可以是浮点数，类对象以及字符串。

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

讲到这里我们可以对比一下c++11的新特性的array.

这个数组和传统数组的区别在于，传统数组对于越界检查是抽查，array对于越界检查是全面检查。

从上图我们可以看到，传统数组都越界写了竟然没有检查出来越界，而array是可以检查出来的。但是这个array我们会用吗？其实不会，因为我们直接用vector是最方便的，没必要用array，并且array的空间在栈上，如果数据过多会将栈搞崩溃，而vector空间在堆上完全不受影响。

二、模板的特化

1.引入概念

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
	friend ostream& operator<<(ostream& _cout, const Date& d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};
template <class T>
bool Less(T left,T right)
{
	return left < right;
}
int main()
{
	cout << Less(1, 2) << endl; // 可以比较，结果正确
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl; // 可以比较，结果正确
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;  //可以比较，结果错误
	return 0;
}

对于上面的代码我们用了以前的日期类做例子，然后用一个Less函数比较日期的大小，通过结果发现对于指针的比较是错误的，如下图：

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

那么这个时候该怎么办呢？我们就需要对模板进行特化，只针对Date*类型，如下图：

//模板特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

对于模板特化我们必须在函数名后面显式类型，看一下特化后的结果:

可见确实完成了我们的任务，刚刚我们演示的模板特化被称为全特化，就是参数的类型都是确定的。

//模板特化   半特化
template<class T>
bool Less(T* left, T* right)
{
	return *left < *right;
}

我们的特化不一定非要确认类型，比如上面的半特化直接将所有指针类型包含了，我们的两个int*的指针去比较结果也是正确的。

模板特化分为函数模板特化和类模板特化。

下面我们讲解一下类模板特化：

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

int main()
{
	Date<int,int> d1;
	Date<int, char> d2;
	return 0;
}

对于类模板特化我们可以特化不同版本的类，比如上面代码中的(int,int)的类和(int,char)的类。并且上述代码中都是全特化，将模板参数列表中所有的参数都确定化，下面我们在演示一下偏特化：

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(const T1& d1, const T2& d2)
 : _d1(d1)
 , _d2(d2)
 {
 cout<<"Data<T1&, T2&>" <<endl;
 }
 
private:
 const T1 & _d1;
 const T2 & _d2; 
 };

引用做模板参数不是很常见，但是我们在实现list的迭代器的时候见到过模板参数是引用。