C++模板的特化超详细精讲

目录

一、泛型编程

我们前面已经学过函数的重载，实现了在函数名相同的情况下，实现不同的功能！

例如：

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

利用函数重载虽然实现了“通用”的交换函数，但是会有以下问题：

重载的函数仅仅是类型不同，代码复用率低，只要有新的类型时，有需要用户自己增加新的重载函数。代码的可维护性低，一个出错可能所有的重载都出错。

⭐️⭐️⭐️：在C++中是否存在一个模具，通过给这个模具中填充不同的材料(类型），来获得不同的铸件（即生成具体的代码）。

泛型编程：编写与类型无关的通用代码，是代码复用的一种的手段。模板是泛型编程的基础。

二、函数模板

2.1、函数模板的概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2、函数模板的格式

template<typename>

返回值类型 函数名（参数列表）{}

template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

⚠️注意：typename 是用来定义函数模板参数关键字的，也可以用class，但是不可以用struct。

2.3、函数模板的原理

函数模板我们可以理解为一个蓝图，它本身并不是函数，在编译器编译阶段根据传入的实参类型来推演生成对应类型的函数以供调用，也叫做函数模板的实例化。

2.4、函数模板的实例化

用不同类型的对象使用函数模板时，称为函数模板的实例化。模板参数实例化分为隐式实例化和显示实例化。

2.4.1、隐式实例化

让编译器根据实参推演模板参数的实际类型。

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main(){
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, a2);
	Add(d1, d2);
	//Add(a1, d1);
	Add(a1, (int)d1);
	system("pause");
	return 0;
}

2.4.2、显示实例化

让函数名后的<>中指定模板参数的实际类型。

int main(){
	int a = 10;
	double b = 20.0;
	//Add(a, (int)b);//隐式
	Add<int>(a, b);//显示
	system("pause");
	return 0;
}

Add(a, b);目的在于如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

三、类模板

3.1、类模板的定义格式

template<typename>

class 类模板名

{

//类内成员

}；

3.1、类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化传的是类型，而函数模板实例化传的是对象，类模板实例化需要在类模板名字后面跟上<>，然后将实例化类型放在<>中即可！

vector<int> s1;

⚠️:与普通类不同，这里vector是类名，而vector才是类型。

四、模板的特化

4.1、概念

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

template<class T>
bool Less(T left, T right){
	return left < right;
}
//特化
template<>
bool Less<Date*>(Date* p1, Date* p2)
{
	cout << "调用的模板函数的特化" << endl;
	return *p1 < *p2;
}
//只要是指针  都可以调用这个，这个思想很重要
//偏特化的带限制条件（指针类型可调）
template<class T>
bool Less(T* left, T* right)
{
	cout << "调用的函数模板" << endl;
	return *left < *right;
}

代码解释：当我们在实参部分传的是Date型指针的时候，如果不特化处理，结果会出错。

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

4.2、函数模板特化步骤

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

template<class T>
bool Less(T left, T right){
	return left < right;
}
//特化
template<>
bool Less<Date*>(Date* p1, Date* p2)
{
	cout << "调用的模板函数的特化" << endl;
	return *p1 < *p2;
}

4.3、类模板的特化

4.3.1、全特化

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

//类模板
template<class T1, class T2>
class data
{
public:
	data(T1 a, T2 b)
		:_a(a)
		, _b(b)
	{
		cout << "data<T1, T2>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};
//全特化
template<>
class data <int, char>
{
public:
	data(int a, char b)
		:_a(a)
		, _b(b)
	{
		cout << "全特化data<int, char>" << endl;
	}
private:
	int _a;
	char _b;
};
int main()
{
	data<int, int> s1(1, 2);
	data<int, char> s2(1, 'a');
}

4.3.2、偏特化

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

//类模板
template<class T1, class T2>
class data{
public:
	data(T1 a, T2 b)
		:_a(a)
		, _b(b)
	{
		cout << "data<T1, T2>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};

⭐️⭐️⭐️偏特化有以下两种变现方式：

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

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

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

// 2、偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
template<class T1, class T2>
class data <T1*, T2* > {
public:
	data(T1 a, char b)
		:_a(a)
		, _b(b)
	{
		cout << "Data<T1*, T2*>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};
template<class T1, class T2>
class data<T1&, T2&>
{
public:
	data(const T1& a, const T2& b)
		:_a(a)
		, _b(b)
	{ cout << "Data<T1&, T2&>" << endl; }
private:
	const T1& _a;
	const T2& _b;
};
int main(){
	data<char*, char*> s6(1,2);
	data<int&, int&> s7(1, 2);
	system("pause");
	return 0;
}

代码解释：

第一个是两个参数特例化为指针类型（只要传的是指针，就走对应的）。第二个是两个参数特例化为引用类型。

到此这篇关于C++模板的特化超详细精讲的文章就介绍到这了,更多相关C++模板特化内容请搜索易采站长站以前的文章或继续浏览下面的相关文章希望大家以后多多支持易采站长站！