非类型模板参数

模板参数分为类型形参和非类型形参：

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

STL容器 array 就有一个非类型形参：

这是一个静态数组，不常用。

例子：

我们可以用它来创建大小不同的静态栈

template<class T, size_t N>
class Stack
{
private:
	T _a[N];
	int _top;
};

int main()
{
	Stack<int, 100> st1; //创建大小为100的静态栈
	Stack<double, 50> st2; //创建大小为50的静态栈
	return 0;
}

注意：

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

模板的特化

模板的特化，就是让模板针对某些类型进行特殊化处理。

函数模板的特化

比如，下面写一个比较大小的函数模板：

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

void test1()
{
	cout << Less(1, 2) << endl;		//可以比较， 结果正确

	Date d1(2022, 7, 19);
	Date d2(2022, 7, 18);
	cout << Less(d1, d2) << endl;	//可以比较，结果正确

	Date* p1 = new Date(2022, 7, 19);
	Date* p2 = new Date(2022, 7, 18);
	cout << Less(p1, p2) << endl;	//可以比较，结果错误
}

int 类型、Date 类型当然可以正常比较，而指针比较的是地址，结果与用户的原意不符。

当然可以对指针解引用后传入，但是如果一定要传指针呢，如何得到正确的答案？

函数模板特化的步骤：

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

例子：

template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

👆：这就是对 Date* 类型的一个特化。

👆：当 cout << Less(p1, p2) << endl; 时，函数就会调用这个特化的模板实例化。

如果函数模板，函数模板的特化，现有的函数同时存在则编译器优先调用现有的函数。

// 优先调用👇
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

👆：也就是说，不特化，直接写一个现成的函数也可以。

类模板的特化

全特化

对如下类模板特化：

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

特化 int double 类型：

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

void test2()
{
	Data<int, int> d1;
	Data<int, double> d2;
}
//结果：
//Date<T1, T2>
//Date<int, double>

这就叫全特化

半特化/偏特化

全特化和半特化类似于全缺省和半缺省的关系。只特化一部分。

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

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

针对指针的特化：

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

针对引用的特化：

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

T1 和 T2 是只要都是指针类型就会调用上一个，都是引用类型就会调用下一个：

void test2()
{
	Data<int*, char*> d4;
	Data<int&, char&> d5;
}
//结果：
//Data<T1*, T2*>
//Data<T1&, T2&>

样例

对日期类对象进行排序。

数组 v1 存日期类对象，数组 v2 存日期类对象的指针。

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

template<class T>
struct Less<T*>
{
	bool operator()(T* x, T* y) const
	{
		return *x < *y;
	}
};

void test3()
{
	Date d1(2022, 7, 18);
	Date d2(2022, 7, 17);
	Date d3(2022, 7, 20);
	vector<Date> v1;
	v1.push_back(d1);
	v1.push_back(d2);
	v1.push_back(d3);
	sort(v1.begin(), v1.end(), Less<Date>());

	vector<Date*> v2;
	v2.push_back(&d1);
	v2.push_back(&d2);
	v2.push_back(&d3);
	sort(v2.begin(), v2.end(), Less<Date*>());
}