【C++】模板进阶

1.非类型模板参数

模板参数分为类型模板参数和非类型模板参数。

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

#define N 100

//定义一个静态数组
template<class T>
class Array
{
private:
	T _a[N];
};

int main()
{
	Array<int> a;
	Array<double> d; 
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

现在数组大小是默认是100个，那对象d想要数组大小1000个该怎么办？

如果把N变成1000是可以满足d，那a对象数组大小100该如何保证呢？
这里引入了非类型模板参数。

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

//定义一个静态数组
template<class T, size_t N = 100>
class Array
{
private:
	T _a[N];
};

int main()
{
	Array<int> a; 
	Array<double,1000> d; 
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：

1.非类型模板参数，只能是整型常量，而浮点数，类对象以及字符串是不允许作为非类型模板参数的。

2.非类型模板参数必须在编译期就能确认结果。

到目前为止stirng，vector，list等容器没有见到哪一个有这个参数的。其实有一种容器用到这个非类型模板参数。

C++的array与C的数组是等价的。

int a[10];
Array<int, 10> a;
1
2

那C++何必再增加一个array类呢？难道就是为了封装，使用方便？

其实主要就是C数组与C++array对于越界的检查。

C对于越界读不检查。

虽然里面是随机值，但是没报错。

C对于越界写抽查。

而array对于读写都会检查。这对于前面模拟实现过vector，list等应该都清楚里面会做检查。

2.模板的特化

2.1概念

通常情况下，使用模板可以实现一些与类型无关的代码，但是对于一些特殊类型可能会得到一些错误的结果。

class Date
{
public:
	Date(int year=2000,int month =1,int day=1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	bool operator==(const Date& d) const
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

	bool operator!=(const Date& d) const
	{
		return !operator==(d);
	}

	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 !operator>(d);
	}

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(2021, 1, 23);
	Date d2(2021, 1, 25);
	cout << Less(d1, d2) << endl;

	Date* D1 = &d1;
	Date* D2 = &d2;
	cout << Less(D1, D2) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

看运行结果

第三种虽然可以比较，但是运行错误。

也就是说明比大小的模板Less不满足我们的需求，此时，就需要对模板进行特化。即：在原模版类的基础上，针对特殊类型所进行特殊化的实现方式。

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

2.2函数模板特化

函数模板特化步骤：

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

//函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//针对某些类型进行的特化 ---Date*
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

增加这个特殊类型的比较，结果就没问题了。
Date*传过去直接会去走下面特殊类型的函数模板，然后函数模板模板再实例化成对应的函数再比较。

中间多个一个实例化太麻烦，因此，一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

2.3类模板特化

2.3.1全特化

全特化即是将模板参数列表中所有的参数都是确定化。

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

//全特化
template<>
class Data<double, int>
{
public:
	Data()
	{
		cout << "Data" << endl;
	}
};

int main()
{
	Data<int, int> d1;
	Data<double, double> d2;
	//特化
	Data<double, int> d3;//直接走特化
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.3.2偏特化

偏特化：针对模板参数进一步进行条件限制设计的特化版本。

template<class T1,class T2>
class Data
{
public:
	Data()
	{
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
1
2
3
4
5
6
7
8
9
10
11
12

偏特化有以下两种表现方式：

1.部分特化

将模板参数表中的一部分参数特化

template<class T1>
class Data<T1,char>
{
public:
	Data()
	{
		cout << "Data" << endl;
	}
private:
	T1 _d1;
};
1
2
3
4
5
6
7
8
9
10
11

不管第一个参数是什么，只要第二个参数是我需要的特化，就去走那个特化。

2.参数进一步限制

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

//两个参数偏特化为指针类型
template<class T1, class T2>
class Data<T1*,T2*>
{
public:
	Data()
	{
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};


//两个参数偏特化为指针类型
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data()
	{
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

注意，必须两个参数都符合才会走对应的特化。

3.模板分离编译

在C++模板初阶对于模板声明和定义的分离做了详细总结，这里不再细说。

4.模板总结

【优点】

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性

【缺陷】

3. 模板会导致代码膨胀问题，也会导致编译时间变长
4. 出现模板编译错误时，错误信息非常凌乱，不易定位错误