• N是常量不能修改
• 模板不仅可以不定义类型，还可以定义常量
• 比宏更好，可以传一个常量过去，定义不同的对象，可以传不同的常量过去

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

#include<iostream>
using namespace std;
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;
}

所以针对日期类指针这种特殊的成员变量的比较，我们引入了模板的特化：

 什么时候该用特化呢？

其实模板特化中分为函数模板特化与类模板特化。我们下面分开讲解：

（2）函数模板的特化

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

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//类模板的特化 -- 全特化（写死了）
template<>
class Data<int, double>
{
public:Data() { cout << "Data<int, double>" << endl; }
};

• 制定好了两个模板参数 —— 写死了
• 只能固定的类型走这个函数
• 例如：只能是int 和 double走全特化的模板

2、偏特化（半特化）

//半特化 / 偏特化（）半特化不是特化一半
//1、将部分模板参数列表中的一部分参数特化
template<class T1>
class Data<T1, char>
{
public:Data() { cout << "Data<T1, char>" << endl; }
};//2、偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本
//只要T1 和 T2是指针就走这个 -- 针对指针特殊化处理
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; }
};int main()
{Data<int, int> d1;Data<int, double> d2;//只要第二个是char都会匹配：半特化/偏特化Data<int, char> d3;Data<char, char> d4;//只要是两个指针Data<int*, int*> d5;Data<int*, char*> d6;Data<int*, string*> d7;Data<int*, void*> d8;//void不是类型，但是void*是一个类型，void*是不能解引用不能++Data<int*, int> d9;//匹配原生的指针Data<int&, char&> d10;return 0;
}//也可以写成typename
//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 = T1(), const T2& d2 = T2())
//		: _d1(d1)
//		, _d2(d2)
//	{
//		cout << "Data<T1&, T2&>" << endl;
//	}
//
//private:
//	const T1& _d1;
//	const T2& _d2;
//};
//
//template <typename T1, typename T2>
//class Data <T1&, T2*>
//{
//public:
//	Data(const T1& d1 = T1())
//
//	{
//		cout << "Data<T1&, T2*>" << endl;
//	}
//};
//int main()
//{
//	Data<int, int> d1;
//	Data<int*, char*> d2;
//	Data<int*, int> d3;
//	Data<double, int> d4;
//
//	Data<int*, int*> d5;
//
//	Data<int&, char&> d6;
//	Data<int&, char*> d7;
//
//	return 0;
//}
//

//模板的特化 -- 应用
template<class T>
struct Less
{bool operator()(const T& x, const T& y) const{return x < y;}
};template<>
struct Less<Date*>
{bool operator()(Date* x, Date* y) const{return *x < *y;}
};//偏特化
//只要是指针都走这里
template<class T>
struct Less<T*>
{bool operator()(T* x, T* y) const{return *x < *y;}
};int main()
{Date d1(2022, 7, 7);Date d2(2022, 7, 6);Date d3(2022, 7, 8);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);//可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序//此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象//但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期sort(v2.begin(), v2.end(), Less<Date*>());vector<int*> v3;v3.push_back(new int(3));v3.push_back(new int(1));v3.push_back(new int(2));sort(v3.begin(), v3.end(), Less<int*>());return 0;
} 

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