目录
1. 非类型模板参数
- 模板参数分为类类型形参与非类型形参。
- 类型模板参数:出现在模板参数列表中,跟在class或者typename之类的参数类型名称。
- 非类型模板参数:就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用。
假设我现在有一个静态栈:
//静态栈 template<class T, size_t N> class Stack { private: T _a[N]; int _top; };
如果现在想指定实例化对象中创建数组的大小,那么就需要借助非类型模板参数来完成:
int main() { Stack<int, 100> st1;//定义一个大小为100的静态数组 Stack<double, 500> st2;//定义一个大小为500的静态数组 return 0; }
这里非类型模板参数在C语言中是通过宏来实现的,只不过宏不能使多个对象指定大小,宏只能统一更改大小,具有单一性,这里C++的非类型模板参数刚好可以解决这一问题。
注意:
- 1、浮点数、类对象以及字符串是不允许作为非类型模板参数的(只能是整型int、char……)。
- 2、非类型的模板参数必须在编译期就能确认结果。
- 3、非类型模板参数给出的值为常量,意味着不能修改:
2. 模板的特化
2.1 概念
通常情况下,使用模板可以实现一些与类型无关的代码,但对于一些特殊类型的可能会得到一些错误的结果,需要特殊处理,比如:实现了一个专门用来进行小于比较的函数模板。
template<class T> bool Less(T left, T right) { return left < right; } int main() { cout << Less(1, 2) << endl; //1 可以比较,结果正确 Date d1(2022, 7, 7); Date d2(2022, 7, 8); cout << Less(d1, d2) << endl; //1 可以比较,结果正确 Date* p1 = new Date(2022, 7, 16); Date* p2 = new Date(2022, 7, 15); cout << Less(p1, p2) << endl; // 0/1 可以比较,结果错误 }
可以看到,Less绝对多数情况下都可以正常比较,但是在特殊场景下就得到错误的结果。上述示例中,p1指向值显然大于p2指向的值,但是Less内部并没有比较p1和p2指向的对象内容,而比较的是p1和p2指针的地址,我p1和p2都是new出来的,无法确定是谁先new的,也就无法判断谁大。这就无法达到预期而错误。
此时,就需要对模板进行特化(虽然传递*p1和*p2也可)。即:在原模板类的基础上,针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
2.2 函数模板特化
函数模板的特化步骤:
- 必须要先有一个基础的函数模板
- 关键字template后面接一对空的尖括号<>
- 函数名后跟一对尖括号,尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误。
// 函数模板 -- 参数匹配 template<class T> bool Less(T left, T right) { return left < right; } // 对Less函数模板进行特化 template<> bool Less<Date*>(Date* left, Date* right) { return *left < *right; }
注:一般情况下如果函数模板遇到不能处理或者处理有误的类型,为了实现简单通常都是将该函数直接给出。
bool Less(Date* left, Date* right) { return *left < *right; }
该种实现简单明了,代码的可读性高,容易书写,因为对于一些参数类型复杂的函数模板,特化时特别给出,因此函数模板不建议特化。
2.3 类模板特化
2.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; } }; int main() { Data<int, int> d1;//Data<T1, T2> Data<int, double> d2;//Data<int, double> Data<char, double> d3;//Data<T1, T2> }
全特化是要参数均匹配才能调用全特化,否则调用默认的模板。
2.3.2 偏特化
偏特化:任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类:
template<class T1, class T2> class Data { public: Data() { cout << "Data<T1, T2>" << endl; } private: T1 _d1; T2 _d2; };
偏特化有以下两种表现方式:
- 1、部分特化:
将模板参数类表中的一部分参数特化。
template<class T1, class T2> class Data { public: Data() { cout << "Data<T1, T2>" << endl; } }; //全特化: template<> class Data<int, double> { public: Data() { cout << "Data<int, double>" << endl; } }; //半特化/偏特化 template <class T1> class Data<T1, char>// 将第二个参数特化为char { public: Data() { cout << "Data<T1, char>" << endl; } private: T1 _d1; int _d2; }; int main() { Data<int, int> d1;//Data<T1, T2> 普通 Data<int, double> d2;//Data<int, double> 全特化 Data<char, double> d3;//Data<T1, T2> 普通 //只要第二个参数为char都会匹配半特化(偏特化) Data<int, char> d4;//Data<T1, char> 偏特化 Data<char, char> d5;//Data<T1, char>偏特化 }
- 2、参数更进一步的限制
偏特化并不仅仅是指特化部分参数,而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
两个参数偏特化为指针类型:
template<class T1, class T2> class Data { public: Data() { cout << "Data<T1, T2>" << endl; } }; //全特化: template<> class Data<int, double> { public: Data() { cout << "Data<int, double>" << endl; } }; //半特化/偏特化 template <class T1> class Data<T1, char>// 将第二个参数特化为char { public: Data() { cout << "Data<T1, char>" << endl; } }; //两个参数偏特化为指针类型 template <class T1, class T2> class Data <T1*, T2*>//只要你T1和T2是指针,就走这里 { public: Data() { cout << "Data<T1*, T2*>" << endl; }; }; int main() { Data<int, int> d1;//Data<T1, T2> 普通 Data<int, double> d2;//Data<int, double> 全特化 Data<char, double> d3;//Data<T1, T2> 普通 //只要第二个参数为char都会匹配半特化(偏特化) Data<int, char> d4;//Data<T1, char> 偏特化 Data<char, char> d5;//Data<T1, char>偏特化 //两个参数为指针 Data<int*, int*> d6;//Data<T1*, T2*> Data<int*, string*> d7;//Data<T1*, T2*> //只有一个参数是指针不算 Data<int*, int> d8;//Data<T1, T2> Data<int*, char> d9;//Data<T1, char> }
两个参数偏特化为引用类型:
template<class T1, class T2> class Data { public: Data() { cout << "Data<T1, T2>" << endl; } }; //全特化: template<> class Data<int, double> { public: Data() { cout << "Data<int, double>" << endl; } }; //半特化/偏特化 template <class T1> class Data<T1, char>// 将第二个参数特化为char { public: Data() { cout << "Data<T1, char>" << endl; } }; //两个参数偏特化为指针类型 template <class T1, class T2> class Data <T1*, T2*>//只要你T1和T2是指针,就走这里 { public: Data() { cout << "Data<T1*, T2*>" << endl; }; }; //两个参数偏特化为引用类型 template <class T1, class T2> class Data <T1&, T2&>//只要你T1和T2是指针,就走这里 { public: Data() { cout << "Data<T1&, T2&>" << endl; }; }; int main() { Data<int, int> d1;//Data<T1, T2> 普通 Data<int, double> d2;//Data<int, double> 全特化 Data<char, double> d3;//Data<T1, T2> 普通 //只要第二个参数为char都会匹配半特化(偏特化) Data<int, char> d4;//Data<T1, char> 偏特化 Data<char, char> d5;//Data<T1, char>偏特化 //两个参数为指针 Data<int*, int*> d6;//Data<T1*, T2*> Data<int*, string*> d7;//Data<T1*, T2*> //只有一个参数是指针不算 Data<int*, int> d8;//Data<T1, T2> Data<int*, char> d9;//Data<T1, char> //两个参数为引用 Data<int&, char&> d10;//Data<T1&, T2&> Data<int, char&> d11;//Data<T1, T2> //指针引用混用,调用的是普通的 Data<int*, char&> d12;//Data<T1, T2> }
2.3.3 类模板特化示例
- 全特化运用场景:
#include<vector> #include <algorithm> template<class T> struct Less { bool operator()(const T& x, const T& 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; }
通过观察上述程序的结果发现,对于日期对象可以直接排序,并且结果是正确的。但是如果待排序元素是指针,结果就不一定正确。因为:sort最终按照Less模板中方式比较,所以只会比较指针,而不是比较指针指向空间中内容,此时可以使用类版本特化来处理上述问题:
// 对Less类模板按照指针方式特化 template<> struct Less<Date*> { bool operator()(Date* x, Date* y) const { return *x < *y; } };
// 对Less类模板按照指针方式特化 template<> struct Less<Date*> { bool operator()(Date* x, Date* y) const { return *x < *y; } };
特化之后,再运行上述代码,就可以得到正确的结果。
- 偏特化运用场景:
#include<vector> #include <algorithm> 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; } }; //偏特化 template<class T> struct Less<T*>//只要你是指针,都走我 { bool operator()(T* x, T* y) const { return *x < *y; } }; int main() { //偏特化运用场景 vector<int*> v3; v3.push_back(new int(3)); v3.push_back(new int(1)); v3.push_back(new int(2)); sort(v3.begin(), v3.end(), Less<int*>()); return 0; }
3. 模板总结
优点:
- 模板复用了代码,节省资源,更快的迭代开发,C++的标准模板库(STL)因此而产生。
- 增强了代码的灵活性。
缺点:
- 模板会导致代码膨胀问题,也会导致编译时间变长。
- 出现模板编译错误时,错误信息非常凌乱,不易定位错误。