C++ 模板进阶（模板的特化）

冰果滴

已于 2023-09-26 12:00:56 修改

阅读量1.2k

点赞数 3

分类专栏： C++学习-笔记文章标签： c++ STL 模板

于 2022-07-22 23:12:41 首次发布

本文链接：https://blog.csdn.net/qq_60750110/article/details/125861059

版权

C++学习-笔记专栏收录该内容

27 篇文章 4 订阅

订阅专栏

前言：这里我们再次学习模板，这次是进阶模板，要比上次所学的模板更深一些，包括非类型模板参数以及函数模板的特化、类模板的全特化、偏特化等。

一.非类型模板参数

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

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

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

template<class T, size_t N = 10>
class Stack
{
public:
	void f()
	{
        // 非类型形参不能修改
		// N = 10;
	}
private:
	T _a[N];
	int _top;
};

注意：①浮点数、类对象以及字符串是不允许作为非类型模板参数的。

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

二.模板的特化

1.概念

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

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 = new Date(2022, 7, 16);
	Date* p2 = new Date(2022, 7, 15);
	cout << Less(p1, p2) << endl;  // 可以比较，结果错误

	int* p3 = new int(1);
	int* p4 = new int(2);
	cout << Less(p3, p4) << endl;  // 可以比较，结果正确

	return 0;
}

Less函数模板在大多数情况都可以正常比较，但是在特殊场景下就得到错误的结果。这里应该比较p1和p2指向的对象的内容，但是比较的却是p1和p2指针的地址。

这时，就需要对模板进行特化。

特化：在原模板类的基础上，针对特殊类型所进行的特殊化的实现方式。模板特化分为函数模板特化和类模板特化。

2.函数模板特化

注意：函数模板基本不用特化处理，直接写一个具体类型的函数更好。

函数模板特化步骤：

① 必须要先有一个基础的函数模板

② 关键字template后面接一对空的尖括号<>

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

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

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

// 针对某些类型要特殊化处理
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

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

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 = new Date(2022, 7, 16);
	Date* p2 = new Date(2022, 7, 15);
	cout << Less(p1, p2) << endl;  // 可以比较，结果正确

	int* p3 = new int(1);
	int* p4 = new int(2);
	cout << Less(p3, p4) << endl;  // 可以比较，结果正确

	return 0;
}

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

这里直接写具体类型的函数，代码可读性高，容易书写，因此直接写具体类型的函数要比函数模板特化好。

3.类模板特化

（1）全特化

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

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

全特化的template后的尖括号<>中不需要写类型，但要在类后面写上要特化的具体类型。

（2）偏特化（半特化）

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

偏特化分为两种：

①部分特化

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

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

部分特化时，需要在template后的尖括号<>中写出不进行特化的参数，然后在下面类后面写出不特化的参数和特化的具体的参数。

②对模板参数更进一步的条件限制

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

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

进一步进行条件限制时，上面template的尖括号<>后面的参数不变，但在下面类后面要加上想要进一步限制的具体类型。

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

// 半特化/偏特化
// 1、将模板参数类表中的一部分参数特化。
template<class T1>
class Data<T1, char>
{
public:
	Data() { cout << "Data<T1, char>" << endl; }
};

// 2、偏特化并不仅仅是指特化部分参数，还指针对模板参数更进一步的条件限制所设计出来的一个特化版本。
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;    // 调用全特化版本
	Data<int, char> d3;      // 调用偏特化版本
	Data<char, char> d4;     // 调用偏特化版本
	Data<int*, int*> d5;     // 调用特化的指针版本
	Data<int*, char*> d6;    // 调用特化的指针版本
	Data<int*, string*> d7;  // 调用特化的指针版本
	Data<int*, void*> d8;    // 调用特化的指针版本
	Data<int*, int> d9;      // 调用基础模板
	Data<int&, char&> d10;   // 调用特化的引用版本

	return 0;
}