【C++进阶】模板进阶-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C++进阶】模板进阶。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

👦个人主页：@Weraphael
✍🏻作者简介：目前学习C++和算法
✈️专栏：C++航路
🐋 希望大家多多支持，咱一起进步！😁
如果文章对你有帮助的话
欢迎评论💬 点赞👍🏻 收藏 📂 加关注✨

前言

初阶模板地址：点击跳转

一、typename和class的区别

在以前博客我们说过，定义模板参数关键字可以用typename，也可以用class，它们是没有区别的，可是真的没有区别吗？来看看以下这个例子

假设要打印容器的数据，要封装一个打印函数（以迭代器的方式）

#include <iostream>
#include <vector>
using namespace std;

void Print(const vector<int>& v)
{
	vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
}

int main()
{
	vector<int> v{ 10,20,30,40,50 };

	Print(v);

	return 0;
}

【输出结果】

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

以上代码虽然可以正常输出，但它只能打印vector<int>类型容器的数据，若要打印vector<double>，又或者是list容器的数据，那么这样就写死了，有人想可以用函数模板。

代码如下：

#include <iostream>
#include <vector>
using namespace std;

// 把class换成typename也是可以的
template<class Container>
void Print(const Container& v)
{
	Container::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
}

int main()
{
	vector<int> v{ 10,20,30,40,50 };

	Print(v);

	return 0;
}

【输出结果】

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

使用函数模板后发现以上代码报错了，提示说需要在Container前加上typename

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

那么为什么必须要加上typename呢？

这是因为代码在编译阶段，会进行语法检查，当编译到Container::const_iterator it时，由于Container还没实例化，那么此时编译器区分不了Container::const_iterator是静态成员变量还是类型。vector<int>是实例化出来的，加上域作用限定符::去找其内嵌类型(迭代器)，所以不会报错。因此，编译器要求加上typename告诉Container是类型。

二、非类型模板参数

2.1 概念

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

类型形参：出现在模板参数列表中，跟在class或者typename之后的参数类型名称。（在模板初阶已经详细讲解过了）
非类型形参：将常量作为类或者函数模板的一个参数，在类或者函数模板中可将该参数当成常量来使用。

2.2 实际用途

举个例子：定义一个静态栈

#define N 10

template <class T>
class stack
{
public:
private:
    T _a[N];
    int _top;
};

如果用define那么栈的固定大小就已经被定死了

因此，C++引入新语法非类型模板参数

// size_t N 可以给默认缺省参数，也可以不给
template <class T, size_t N = 10>
class stack
{
public:
private:
    T _a[N];
    int _top;
};

int main()
{
    stack<int, 100> s1;
    stack<int, 50> s2;
}

需要注意的是，非类型模板参数必须满足以下两点：

必须是常量，不可被修改
必须是整型。整型家族有：char、short、bool、int、long、long long等

因此可以得出，非类型模板参数一般是用来定义一个数组的大小的

2.3 实际例子：array容器（C++11）

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

在C++11标准中，引入了一个容器array，它的底层使用了非类型模板参数，是一个真正意义上的泛型数组，这个是用来对标C语言传统数组的。

以下是array容器的基本用法

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

看完以上接口，array支持的，C语言数组也都是支持的。那么它们有什么区别呢？

array也并没有进行初始化。

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

array对于越界读、写检查更为严格。传统数组越界读写，不会发生报错；而array数组则会报错。

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

虽然对越界行为检查严格，但在实际开发中，很少使用array容器，因为它对标传统数组，连初始化都没有，而vector也是类似于数组的容器，在功能和实用性上可以全面碾压，并且 array使用的是栈区上的空间，会存在栈溢出问题，因此可以说array是一个鸡肋的容器。

三、模板特化

3.1 概念

模板特化顾名思义就是对模板(泛型思想)的特殊化处理 。模板特化中分为函数模板特化与类模板特化。

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

比如：实现一个专门用来进行小于比较的函数模板

#include <iostream>
using namespace std;

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

int main()
{
	int a = 1;
	int b = 2;
	cout << Less(a, b) << endl; // 可以比较，结果正确

	int* p1 = &a;
	int* p2 = &b;
	cout << Less(p1, p2) << endl; // 可以比较，结果错误
	
	return 0;
}

【输出结果】

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

上述示例中，p1指向的a显然小于p2指向的b，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址。

因此，就需要对模板进行特化。即在原模板函数的基础上，针对特殊类型所进行特殊化的实现方式。

3.2 函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参必须要和基础的模板函数的基础参数类型完全相同

#include <iostream>
#include <vector>
using namespace std;

// 1. 必须要先有一个基础的函数模板
template<class T>
bool Less(T x, T y)
{
	return x < y;
}

// 对Less函数模板进行特化
// 2. 关键字template后面接一对空的尖括号<>
template<>
// 3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
// 4. 函数形参必须要和基础的模板函数的基础参数类型完全相同
bool Less<int*>(int* x, int* y) 
{
	return *x < *y;
}

int main()
{
	int a = 1;
	int b = 2;
	cout << Less(a, b) << endl; // 可以比较，结果正确

	int* p1 = &a;
	int* p2 = &b;
	cout << Less(p1, p2) << endl; // 可以比较，结果错误
	
	return 0;
}

【输出结果】

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

不过对于函数模板特化来说，存在一个更加方便的东西：函数重载同样也能解决特殊需求

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

bool Less(int* x, int* y)
{
	return *x < *y;
}

3.3 类模板特化（重点）

模板特化主要用在类模板中，它可以在泛型思想之上解决大部分特殊问题，并且类模板特化还可以分为：全特化和偏特化

3.3.1 全特化

全特化指将原模板参数列表中所有的参数都确定化

注意：在进行全特化必须满足以下条件

必须要先有一个基础的类模板
全特化模板中的模板参数可以不用写
需要在类名之后，指明具体的参数类型，否则无法实例化出对象

// 必须要先有一个基础的类模板
template<class T1, class T2>
class Test
{
public:
	Test(const T1& t1, const T2& t2)
		:_t1(t1)
		, _t2(t2)
	{
		cout << "Test(const T1& t1, const T2& t2)" << endl;
	}

private:
	T1 _t1;
	T2 _t2;
};

// 假设对int和char类型进行特殊化处理
// 全特化后的类模板
// 2. 全特化模板中的模板参数可以不用写
template<>
// 3. 需要在类名之后，指明具体的参数类型，否则无法实例化出对象
class Test<int, char>
{
public:
	Test(const int& t1, const char& t2)
		:_t1(t1)
		, _t2(t2)
	{
		cout << "Test<int, char>" << endl;
	}

private:
	int _t1;
	char _t2;
};

int main()
{
	Test<int, int> T1(1, 2);
	Test<int, char> T2(20, 'c');
	return 0;
}

调用时会优先选择更为匹配的类模板

【C++进阶】模板进阶,C++,c++,开发语言,c语言,list,visualstudio,笔记

3.3.2 偏特化(半特化)

偏特化有两种表现方式：部分特化和参数更进一步的限制

部分特化

只特化一部分模板参数

// 原模板
template<class T1, class T2>
class Data
{
public:
	Data() 
	{ 
		cout << "Data<T1, T2>" << endl; 
	}

private:
	T1 _d1;
	T2 _d2;
};

// 偏特化

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
	Data() 
	{ 
		cout << "Data<T1, int>" << endl; 
	}
private:
	T1 _d1;
	int _d2;
};

参数更进一步的限制

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

借助偏特化解决指针无法正常比较问题

class Date
{
public:
	Date(int year = 1970, 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);
	}

private:
	int _year;
	int _month;
	int _day;
};

//原来的比较模板
template<class T>
class Less
{
public:
	bool operator()(T x, T y) const
	{
		return x < y;
	}
};

//偏特化后的比较模板
template<class T>
class Less<T*>
{
public:
	bool operator()(T* x, T* y) const
	{
		return *x < *y;
	}
};

int main()
{
	Date d1 = { 2018, 4, 10 };
	Date d2 = { 2023, 5, 10 };

	cout << "d1 < d2: " << Less<Date>()(d1, d2) << endl;
	cout << "&d1 < &d2: " << Less<Date*>()(&d1, &d2) << endl;

	int a = 1;
	int b = 2;
	cout << "&a < &b: " << Less<int*>()(&a, &b) << endl;
	return 0;
}