C++（模板进阶）

最新推荐文章于 2025-06-02 13:01:50 发布

丢掉幻想准备斗争

最新推荐文章于 2025-06-02 13:01:50 发布

阅读量726

点赞数 28

文章标签： c++ 算法开发语言

本文链接：https://blog.youkuaiyun.com/2301_80475151/article/details/143076985

版权

1. 类型模板和非类型模板

模板参数分为类类型形参与非类型形参，类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称；而非类型形参就是用一个常数作为类（函数）模板的一个参数，在类或者函数内可以直接充当一个常量进行使用。

如下代码可见：

//class T就是类型模板
//class size_t N就是非类型模板
template< class T,size_t N = 10 >
class Person
{
public:
	Person()
	{
		cout << "N is:> " << N << endl;
	}

private:
	T arr[N];
};

int main()
{
	Person<int>p;
	return 0;
}

需要注意的是：

1. 只有整型家族才可以作为非类型模板参数，包括（int，char，long，unsigned，bool）等等，可能有人问为什么char类型也可以，因为char类型的底层是ASCII值；bool的Ture和False为1和0表示；

2. 非类型的模板参数必须在编译期就能确定结果即那些动态申请的、非const的都是不可以的；

3. 需要注意的是如果像上面的模板参数有类类型和非类型的话，非类型必须在最后一位；

2. 模板的特化

2.1 概念

一般情况下，使用模板可以实现一些与类型无关的代码，当传入特定值时再形参特定类型的代码，但对于一些特殊类型调用模板的时候可能会得到一些错误的结果需要另外特殊处理；举个例子，当我们写了一个函数进行比较两个数大小的时候，比较他们值的话就会出现错误，如下代码所示：

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

int main()
{
	int a = 5;
	int b = 6;
	int* a1 = &a;
	int* b1 = &b;

	if (com(a, b))
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "b > a" << endl;
	}
	cout << "the parameter is address" << endl;
	if (com(a1, b1))
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "b > a" << endl;
	}
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

我们看第一个传入的是值，他能得出正确的的答案，而第二个我们传入的是值的地址，那他就是按地址的大小进行比较，导致得到错误的结果，出现这种情况后我们就需要对该模板进行特化，特殊化处理，即写一个能处理地址的模板；

2.2 模板的特化

函数模板特化步骤：

1. 必须有一个基础的函数模板；

2. 关键字template后接一对空的尖括号；

3. 函数名后跟一对尖括号，尖括号中写需要特化的特定类型；

4. 特化的函数参数需要和基础参数类型参数完全相同；

语法为：template<>; bool com<类型>(类型 left, 类型 right)；如下代码所示：

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

template<>
bool com<int*>(int* left, int* right)
{
	return *left > *right;
}

int main()
{
	int a = 5;
	int b = 6;
	int* a1 = &a;
	int* b1 = &b;

	if (com(a, b))
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "b > a" << endl;
	}
	cout << "the parameter is address" << endl;
	if (com(a1, b1))
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "b > a" << endl;
	}
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

而这会如果说传入的是地址的话就不会走最上面那个T类型的而是走特化的这个；

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

bool com(int* left, int* right)
{
	return *left > *right;
}

这样得到的结果也还是正确的，还不需要写template<> 还要在函数名前面加特化的类型，但这不代表模板特化就没有用了，在对于一些参数类型复杂的函数模板，特化时特别给出；

2.3 类模板的特化

2.3.1 全特化

全特化即是将模板参数列表中所有的参数都确定化；如下代码所示：

#include<iostream>
using namespace std;

template<class T1, class T2>
class Person
{
public:
	Person()
	{
		cout << "Person<class T1, class T2>" << endl;
	}
private:
	T1 _a1;
	T2 _a2;
};

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

private:
	int _a1;
	char _a2;

};

int main()
{
	Person<int, int> p1;
	Person<int, char> p2;

	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

2.3.2 部分特化 / 偏特化

偏特化即对函数模板参数进行更多的限制，举个例子，例如基础的函数模板参数有两个template<class T1, class T2>，那么我们就在函数名进行一些限制template<class T>; class Person< T1, int>；如下代码所示：

#include<iostream>
using namespace std;

//基础的函数模板
template<class T1, class T2>
class Person
{
public:
	Person()
	{
		cout << "Person<class T1, class T2>" << endl;
	}
private:
	T1 _a1;
	T2 _a2;
};

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

private:
	int _a1;
	char _a2;

};

//偏特化
template<class T>
class Person<T, double>
{
public:
	Person()
	{
		cout << "class Person<T, double>" << endl;
	}
private:
	T _a1;
	double _a2;
};
int main()
{
	Person<int, int> p1;
	Person<int, char> p2;
	Person<int, double> p3;
	Person<double, double>p4;

	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

这种偏特化，第一个参数你可以传任意类型，但第二个参数必须是double；

还有一种偏特化就是传的是指针和引用

#include<iostream>
using namespace std;

//基础的函数模板
template<class T1, class T2>
class Person
{
public:
	Person()
	{
		cout << "Person<class T1, class T2>" << endl;
	}
private:
	T1 _a1;
	T2 _a2;
};

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

private:
	int _a1;
	char _a2;

};

//偏特化
template<class T>
class Person<T, double>
{
public:
	Person()
	{
		cout << "class Person<T, double>" << endl;
	}
private:
	T _a1;
	double _a2;
};

//参数更进一步限制的偏特化
template<class T1, class T2>
class Person<T1*, T2*>
{
public:
	Person()
	{
		cout << "class Person<T1*, T2*>" << endl;
	}
};

template<class T1, class T2>
class Person<T1&, T2&>
{
public:
	Person()
	{
		cout << "class Person<T1&, T2&>" << endl;
	}
};

int main()
{
	Person<int, int> p1;
	Person<int, char> p2;
	Person<int, double> p3;
	Person<double, double>p4;

	Person<int*, int*>p5;
	Person<int&, int&>p6;
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

然后这里面还要一点需要注意的是按着下面这个图看，我们以为int* 传给了T1，T2，实则不是的，如果说我们在里面调用T1和T2的话应该是int类型，而不是int*类型，下面的引用也一样，编译器是为了不把类型写死，所以没有直接传int*类型，如果说我们在里面想用int类型的话可以用，想用int* 类型的话直接T1* 即可；如下图和代码所示：

#include<iostream>
using namespace std;

//参数更进一步限制的偏特化
template<class T1, class T2>
class Person<T1*, T2*>
{
public:
	Person()
	{
		int a = 0;
		T1 b = a;
		T1* c = &a;
		T2* d = &a;
		cout << typeid(b).name() << endl;
		cout << typeid(c).name() << endl;
		cout << typeid(d).name() << endl;
		cout << "class Person<T1*, T2*>" << endl;
	}
};

int main()
{
	Person<int*, int*>p5;
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

引用也一样，这里就不再举例；

最后提一下就是：库内的函数并没有给我们提供特化，举个例子，如果我们想用sort给一些数据排序那是完全可以的，但如果我们传入的是指针的话，则会出错，所以我们需要自己实现一个仿函数对特定类型进行比较即可；如下代码所示：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year = 1900, 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;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}


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

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{
	bool operator()(Date* x, Date* y) const
	{
		return *x < *y;
	}
};
int main()
{
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 6);
	Date d3(2022, 7, 8);
	vector<Date> v1;
	v1.push_back(d1);
	v1.push_back(d2);
	v1.push_back(d3);
	// 可以直接排序，结果是日期升序
	sort(v1.begin(), v1.end(), Less<Date>());
	vector<Date*> v2;
	v2.push_back(&d1);
	v2.push_back(&d2);
	v2.push_back(&d3);
	// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
	// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
	// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
	sort(v2.begin(), v2.end(), Less<Date*>());
	return 0;
}

END!