【C++】模板进阶

//#define N 10
//静态数组
//非类型模板参数 --- 是一个常量
template<class T, int N = 10>//给非类型模板参数缺省值为常量10
class Array
{

private:
	T _a[N];
};

int main()
{
	//Array<int> a1;		// 10
	//Array<double> a2;		// 1000

	Array<int,10> a1;		// 10
	Array<double,1000> a2;  // 1000

	return 0;
}

template<class T,size_t N>
//template<class T,double N>
//浮点数不能作为非类型模板参数，非类型模板参数基本都是整型，int short char，像自定义类型，字符串，浮点型这些都不可以。
void Func(const T& x)
{
	cout << N << x << endl;
}
int main()
{
	//Func<int, 100>(1);
	//Func<int, 100.11>(1);
	
	//int a = 10;
	//Func<int, a>(1);//只能给常量，局部变量不能作为非类型模板参数。

	//非类型模板参数主要还是用于，在类里面定义某些数组时，想要通过非类型模板参数的大小来定义数组大小。
	return 0;
}

int main()
{
	//C++11想让我们用array，不想让我们用C语言的数组了，就因为C语言的越界检查不够严格，容易引发问题。
	int a1[10];
	array<int, 10> a2;//array对比的是C语言的静态数组，并且两个数组都在栈上
	array<int, 100> a3;

	//两者的区别，对于越界的检查: 
	
	//C语言对于越界读，不检查。越界写，是抽查。
	cout << a1[10] << endl;
	cout << a1[15] << endl;
	//a1[10] = 0;//临近位置进行抽查，一般能够抽查出来。
	a1[15] = 0;//但是位置如果离的远了，不一定能抽查出来。

	//C++11的array无论是越界读，还是越界写，都可以检查出来。
	//因为我们模拟实现operator[]时，采用的就是assert断言报错，库的实现也是这样的。
	cout << a2[10] << endl;
	cout << a2[15] << endl;
	//a2[10] = 0;//临近位置进行抽查，一般能够抽查出来。
	a2[15] = 0;

	return 0;
}

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

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

// 针对某些类型进行特殊处理 -- Date*
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}
// 下面这种方式是函数重载
bool Less(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;  // 可以比较，结果错误，地址之间的逻辑比较，可能为0可能为1，因为地址是随机的。

	return 0;
}

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

};

// 类模板的特化 --- 半特化、偏特化
template<class T1>
class Data<T1, char>
{
public:
	Data() { cout << "Data<T1, char>" << endl; }
private:

};

int main()
{
	Data<int, char> d3;// d3和d4都匹配半特化后的模板
	Data<double, char> d4;
}

// 对参数类型的进一步限制 --- 半特化
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<double, double> d2;
	// 优先级队列对于日期类当时的处理方式是显示写仿函数。如果不用仿函数就用原来的类来进行比较，可以通过仿函数类特化来解决
	//将仿函数这个类进行特化，让仿函数对T为Date*类型时进行特殊处理，改为解引用后的内容之间进行比较即可。不用重新写仿函数。

	// 实际特化时，针对的都是较小的类来进行特化的，比如仿函数这样较小的类。

	Data<int, char> d3;// d3和d4都匹配半特化后的模板
	Data<double, char> d4;

	// 有成品吃成品，没有成品吃半成品，没有半成品就用原材料自己做，全特化、半特化、未特化模板

	Data<int*, int*> d5;
	Data<char*, int*> d6;
	Data<char, int*> d7;

	Data<double&, int&> d8;

	//特化的本质体现的是编译器参数的匹配原则，有现成实例化出来的就优先用现成的，没有现成用半成，没有办成就自己进行实例化。

	//遇到一堆模板报出来的错误的时候，先去看第一个错误，不要慌，第一个解决了下面基本就都解决了
	//有的时候模板错误的定位不准，

	return 0;
}