🧑💻作者： @情话0.0
📝专栏：《C++从入门到放弃》
👦个人简介：一名双非编程菜鸟，在这里分享自己的编程学习笔记，欢迎大家的指正与点赞，谢谢！
模板进阶
- 前言
- 一、非类型模板参数
- 二、模板的特化
- 2.1 什么是模板的特化？
- 2.2 函数模板特化
- 2.3 类模板特化
- 2.3.1 全特化
- 2.3.2 偏特化
- 2.3.3 类模板特化应用案例
- 三、模板分离编译
- 3.1 模板的分离编译
- 3.2 解决办法
- 总结
前言
之前我已经写过一篇关于模板的博客，在之前那篇文章的基础之上再对模板进行补充。
链接: 模板初阶
一、非类型模板参数
经过之前的学习我们明白关于模板参数的功能在于事先不知道数据的类型是什么，然后是通过模板参数来进行数据类型的推导，当然模板参数不仅仅只有数据类型，它还包括关于空间适配器的选择，默认情况下栈和队列的底层结构是deque，但是也可以通过传参的方式对底层结构做出改变，还有就是关于仿函数的选择，到底是greater还是less。
模板参数分类类型形参与非类型形参。
类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
比如说要定义一个数组这样的类，那下面的代码感觉还不错的，可定义包含不同的数据类型的数组，还有一定的空间。但是呢？我想要这两个数组拥有不同的大小空间呢？难道要define两个数组大小变量吗？
#define N 10
template<class T>
class Array
{
public:
private:
T _arr[N];
};
int main()
{
Array<int> a1;
Array<double> a2;
return 0;
}
因此就引入了非类型的模板参数------整形常量
template<class T,size_t N = 10>
class Array
{
public:
private:
T _arr[N];
};
int main()
{
Array<int, 10> a1;
Array<double, 20> a2;
return 0;
}
注意：
- 非类型模板参数不能被赋值。
- 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
- 非类型的模板参数必须在编译期就能确认结果。
二、模板的特化
2.1 什么是模板的特化？
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行日期大小比较的函数模板。
// 函数模板 -- 参数匹配
template<class T>
bool Greater(T left, T right)
{
return left > right;
}
int main()
{
cout << Greater(10, 5) << endl; // 可以比较，结果正确
Date d1(2023, 6, 20);
Date d2(2023, 6, 21);
cout << Greater(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Greater(p1, p2) << endl; // 可以比较，结果错误
return 0;
}
可以看到，Greater绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Greater内部并没有比较p1和p2指向的对象内容，而比较的是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;
}
//对于整形数据的地址比较
template<class T>
bool Less(T* left, T* right)
{
return *left < *right;
}
int main()
{
int a = 10, b = 20;
cout << Less(a, b) << endl;
Date d1(2023, 6, 15);
Date d2(2023, 6, 16);
cout << Less(d1, d2) << endl;
Date* p1 = &d1;
Date* p2 = &d2;
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;
}
该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。
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, char>
{
public:
Data()
{
cout << "Data(int, char)" << endl;
}
private:
int _d1;
char _d2;
};
int main()
{
Data<int, int> d1;
Data<int, char> d2;
Data<int, double> d3;
return 0;
}
一定要注意全特化的格式：template后面只跟上一对 “<>” ，在类名后面跟上对应的成员变量的类型。
2.3.2 偏特化
任何针对模版参数进一步进行条件限制设计的特化版本。就针对于全特化来说，只有不将所有模板参数都确定化就是偏特化。
//将第二个参数特化为int
template<class T>
class Data<T, int>
{
public:
Data()
{
cout << "Data<T,int>" << endl;
}
private:
T _d1;
int _d2;
};
//将第一个参数特化为double
template<class T>
class Data<double, T>
{
public:
Data()
{
cout << "Data<double,T>" << endl;
}
private:
double _d1;
T _d2;
};
//两个参数偏特化为指针类型
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
Data()
{
cout << "Data<T1*, T2*>" << endl;
}
private:
T1 _d1;
T2 _d2;
};
//两个参数偏特化为引用类型
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
Data(const T1& d1, const T2& d2)
:_d1(d1), _d2(d2)
{
cout << "Data<T1&, T2&>" << endl;
}
private:
const T1& _d1;
const T2& _d2;
};
int main()
{
Data<int, char> d1;
Data<char, char> d2;
Data<char, int> d3;
Data<double, char> d4;
Data<int*, char*> d5;
Data<int&, int&> d6(1, 2);
return 0;
}
2.3.3 类模板特化应用案例
下面代码关于日期的小于比较：
class Date
{
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);
}
friend ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
template<class T>
struct Less
{
bool operator()(const T& x,const T& y)const
{
return x < y;
}
};
int main()
{
Date d1(2023, 6, 21);
Date d2(2023, 6, 22);
Date d3(2023, 6, 23);
vector<Date> v;
v.push_back(d3);
v.push_back(d1);
v.push_back(d2);
//通过结果观察到是正确的日期排序
sort(v.begin(), v.end(), Less<Date>());
//但是若模板参数类型为指针（地址）类型时就会出现排序错误，因为它是按照地址的大小进行排序的
//因此针对这种情况就要针对原有的类模板进行特化
vector<Date*> v1;
v1.push_back(&d3);
v1.push_back(&d1);
v1.push_back(&d2);
sort(v1.begin(), v1.end(), Less<Date*>());
return 0;
}
//类模板特化
template<>
struct Less<Date*>
{
bool operator()(Date* x, Date* y)const
{
return *x < *y;
}
};
三、模板分离编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
3.1 模板的分离编译
假设说现在要将模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：
//Func.h
template<class T>
T add(const T& x, const T& y);
//Func.cpp
#include "Func.h"
template<class T>
T add(const T& x, const T& y)
{
return x + y;
}
//test.cpp
#include "Func.h"
int main()
{
add(1, 2);
return 0;
}
在运行该部分代码之后出现了这样的错误：
C/C++程序要运行，一般都要进行以下四个步骤：预处理、编译、汇编、链接。
预处理：头文件的展开/宏替换/条件编译/去掉注释…（Func.i）
编译：检查语法，生成汇编代码（Func.s）
汇编：将汇编代码转换为二进制机器码（Func.o）
链接：合并生成可执行文件（a.out）
原因：在经过编译之后，Func被编译成了一堆指令，但是在这堆指令中并没有add函数的地址，这是因为add没有实例化，没办法确定T，因此看不到具体的add函数。而在main.obj中调用add < int > ，编译器在链接时才会找它的地址（在此之前它们是不交互的），但是这个函数没有实例化生成具体代码，因此在链接时报错。
3.2 解决办法
- 模板定义的位置显式实例化。
这种方法不实用，不推荐使用。为什么呢？虽然现在解决了上面的问题，但是，如果add的参数是double类型呢？char类型呢？string或者date类型呢？难道为每一个都要显示实例化一个吗？
//显示实例化
template
int add<int>(const int& x,const int& y);
- 将声明和定义放到同一个文件 “xxx.hpp” 里面。
总结
优点：
- 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
- 增强了代码的灵活性
缺点：
- 模板会导致代码膨胀问题，也会导致编译时间变长
- 出现模板编译错误时，错误信息非常凌乱，不易定位错误
