模版的全特化与偏特化

模版的全特化与偏特化

前言

​ 在现代C++编程中，模板是实现代码泛型化的核心工具。它们允许程序员编写与类型无关的代码，同时保持高效和灵活性。然而，当遇到特定类型时，标准模板可能无法满足需求，或者产生不正确的结果。这就是特化的概念发挥作用的地方。特化允许开发者为特定类型提供定制化的实现，从而优化性能和功能。本文将详细介绍类模板与函数模板的全特化和偏特化，以及如何在C++中有效地使用它们。

---

一、特化概念引出

​ 通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板。

// 首先给出用作演示的类定义
class Date
{
public:
	Date(int year, int month, int day):
		m_year(year), m_month(month), m_day(day){}

	bool operator<(const Date& d)
	{
		if (m_year < d.m_year)
		{
			return true;
		}
		else if (m_year == d.m_year)
		{
			if (m_month < d.m_month)
			{
				return true;
			}
			else if (m_month == d.m_month)
			{
				if (m_day < d.m_day)
				{
					return true;
				}
			}
		}
		return false;
	}
	friend ostream& operator<<(ostream& out, const Date& d);
private:
	int m_year;
	int m_month;
	int m_day;
};
ostream& operator<<(ostream& out, const Date& d)
{
	out << "Date is "
		<< d.m_year << "/"
		<< d.m_month << "/"
		<< d.m_day << "\n";
	return out;
}

函数模版：

template<typename T>
bool upper(T a, T b)
{
	return b < a;
}

测试演示案例：

void test1()
{
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << "d1 upper than d2: " << upper(d1, d2) << endl;
	cout << "p1 upper than p2: " << upper(p1, p2) << endl;
}

运行结果：

可以看到，upper() 绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是 upper() 内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

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

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

二、函数模版特化

函数模板的特化步骤：

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

函数模版定义处新增 模版特化 的函数：

// 函数模版
template<typename T>
bool upper(T a, T b)
{
	return b < a;
}
// 函数模版特化
template<>
bool upper<Date*>(Date* a, Date* b)
{
	return *b < *a;
}

重新运行 test1() 函数：

**注意：**一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

例如：

// 函数模版
template<typename T>
bool upper(T a, T b)
{
	return b < a;
}
// 普通函数
bool upper(Date* a, Date* b)
{
	return *b < *a;
}

正如我们所知，同名普通函数和函数模版可以同时存在，所以不妨直接定义普通函数可以省去很多不必要的麻烦，因此函数模板不建议特化。

三、类模板特化

1. 全特化

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

// 类模板
template<typename T>
class Less
{
public:
	bool operator()(T left, T right)
	{
		return left < right;
	}
};

测试函数：

#include <queue>
void test2()
{
	priority_queue<Date, vector<Date>, Less<Date>> pq;		// 调用普通类模板
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	Date d3(2022, 7, 6);
	pq.push(d1); pq.push(d2); pq.push(d3);
	for (; !pq.empty(); pq.pop())
	{
		cout << pq.top();
	}
	
	cout << "################" << endl;

	Date* p1 = &d1;
	Date* p2 = &d2;
	Date* p3 = &d3;
	priority_queue<Date*, vector<Date*>, Less<Date*>> pq2;	// 调用全特化版本
	pq2.push(p1); pq2.push(p2); pq2.push(p3);
	for (; !pq2.empty(); pq2.pop())
	{
		cout << *(pq2.top());
	}
}

我们知道 priority_queue 可以基于谓词实现自排序，我们对其打印输出观察排序后优先队列内存储的元素顺序：

通过运行结果发现，存储元素为Date的优先队列实现了谓词指定的排序功能，而存储元素为Date*的优先队列呈现非有序状态。

所以对于Less仿函数需要针对Date*实现类的全特化，仅需在类模版声明后定义特化版本即可，代码如下：

// 类模板
template<typename T>
class Less
{
public:
	bool operator()(T left, T right)
	{
		return left < right;
	}
};
// 全特化
template<>
class Less<Date*>
{
public:
	bool operator()(Date* left, Date* right)
	{
		return *left < *right;
	}
};

注意：特化版本需要在类模版后面定义

重新运行 test2() 函数：

发现优先队列排序结果符合设想。

2. 偏特化

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

比如对于以下模板类：

// 多模版参数模版类
template<typename T1, typename T2>
class A
{
public:
	A() { cout << "类模版：A<T1, T2>" << endl; }
private:
	T1 n;
	T2 m;
};

<1> 部分特化 — 偏特化表现形式一

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

template<typename T1>
class A<T1, int>
{
public:
	A() { cout << "偏特化：A<T1, int>" << endl; }
private:
	T1 n;
	int m;
};

<2> 参数更进一步限制 — 偏特化表现形式二

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

template<typename T1, typename T2>
class A<T1*, T2*>
{
public:
	A() { cout << "偏特化：A<T1*, T2*>" << endl; }
private:
	T1 n;
	T2 m;
};

template<typename T1, typename T2>
class A<T1&, T2&>
{
public:
	A(const T1& a_n, const T2& a_m):n(a_n), m(a_m) { cout << "偏特化：A<T1&, T2&>" << endl; }
private:
	const T1& n;
	const T2& m;
};

给出偏特化测试函数：

void test3()
{
	A<double, int> a1;		// 调用特化的int版本
	A<int, double> a2;		// 调用基础的模板
	A<int*, int*> a3;		// 调用特化的指针版本
	A<int&, int&> a4(1, 2); // 调用特化的指针版本
}

运行结果：

---

总结

​ 通过全特化和偏特化，可以为特定类型或条件创建专门的模板实现，从而提高代码的效率和准确性。本文通过示例和详细解释，展示了如何在C++中实现和应用特化，随着对特化的深入理解，读者将能够更好地利用C++模板来构建灵活和高效的代码。