模板的特化

// 函数模板 -- 参数匹配
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绝多数情况下都可以正常进行比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而是比较p1和p2指针的地址，这就无法达到预期而错误。

此时，就需要对模板进行特化。即：在原模版类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板的特化步骤：

1.必须要先有一个基础的函数模板；

2.关键字template后面接一堆空的尖括号；

3、函数名后跟一对尖括号，尖括号中指定需要特化的类型；

4.函数形参表：必须要和模板函数的基础惨淡胡类型完全相同，如果不同编译器可能会报一些奇怪的错误。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
 return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* 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;
}

// 静态栈
// 非类型模板参数
// 1、常量
// 2、必须是整形
template<class T, size_t N>
class Stack
{
public:
	void func()
	{
		// 常量，不能修改
		N = 0;
	}
private:
	T _a[N];
	int _top;
};

//template<class T, double N>
//class BB
//{};

//int main()
//{
//	Stack<int, 10> st1; // 10
//	Stack<int, 100> st2; // 100
//
//	// 按需实例化(调用了才会实例化)
//	//st1.func();
//
//	return 0;
//}

//int main()
//{
//	// C++11
//	// 
//	// 鸡肋
//	//int a[10];
//	array<int, 10> a;
//	a[0] = 0;
//	for (auto e : a)
//	{
//		cout << e << " ";
//	}
//
//	// array对越界的检验非常严格，越界读写都能检查
//	// 普通数组，不能检查越界读，少部分越界写可以检查
//	//a[10];
//
//	vector<int> v(10, 0);
//	//v[10];
//
//	return 0;
//}

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

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

//bool Less(int* left, int* right)
//{
//	return *left < *right;
//}

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

//int main()
//{
//	cout << Less(1, 2) << endl;
//
//	int a = 1, b = 2;
//	cout << Less(&a, &b) << endl;
//
//	double c = 1.1, d = 2.2;
//	cout << Less(&c, &d) << endl;
//
//	return 0;
//}

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

类模板特化

// 假设我针对int double要进行特殊处理
// 全特化
template<>
class Data<int,double>
{
public:
	Data() { cout << "Data<int,double>" << endl; }
private:
};

// 偏特化 ： 特化部分参数
template<class T1>
class Data<T1, double>
{
public:
	Data() { cout << "Data<T1, double>" << endl; }
private:
};

// 偏特化 ： 可能是对某些类型的进一步限制
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
private:
};

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

//int main()
//{
//	Data<int, int> d1;
//	Data<int, double> d2;
//	Data<int*, double> d3;
//	Data<double, double> d4;
//	Data<double*, double*> d5;
//	Data<void*, int*> d6;
//	Data<int&, double&> d7;
//
//	return 0;
//}