C++模板进阶

🕗 发布于 2024-07-06 19:06 c++ 开发语言 笔记

文章目录

系列文章目录
一、前言
二、非类型模板参数
三、模板typename
- 1.使用函数模板遍历容器
四、模板的特化
五、模板的分离编译
六、模板总结
- [优点]
- [缺陷]

在这里插入图片描述

系列文章目录

C++模板的使用

一、前言

在模板初阶我们了解了什么是模板，如何使用模板。函数模板和类模板都是模板。

二、非类型模板参数

1.非类型模板概念

模板参数分类类型形参与非类型形参。

类型形参即:出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

观察下面代码：

#include <iostream>
using namespace std;

#define N 10

template<class T>
class Stack
{
private:
int _a[N];
int _top;
};

如代码中我们使用模板定义的一个栈类。需要修改成员变量数组_a[N]只需要修改宏定义就好了。
这样定义有一个缺陷，如果想要一个栈存100的数据，一个栈存10的数据，这样>使用宏定义是无法完成的。
所以为了更加方便，非类型模板参数规定可以使用常量参数。

Stack<int,100> st1; //100
Stack<int,10> st2; //10

思考一个问题，这俩个栈是一个类出来的吗？

很明显不是一个类出来的。是俩个不同的类。
模板本质是让编译器去帮我们写代码。实际上和手写没有什么区别。

2.参数注意事项

浮点数、类对象以及字符串是不允许作为非类型模板参数的。
非类型的模板参数必须在编译期就能确认结果。

//c++20之前，只能允许整形做非模板参数
//c++20之后，可以支持double等其他内置类型
template<double x,int* ptr>
class A
{};

但c++20之后就可以使用double。

观察下面代码：

#include <iostream>
using namespace std;
template<class T,size_t N>
class Stack
{
public:
void func()
{
N++;
}
private:
int _a[N];
int _top;
};
int main()
{
Stack<int,100> st1; 
//st1.func();//按需实例化
return 0;
}

上面代码中有俩个问题。

未调用对象st1的函数，不会报错，

由于非类型模板参数是常量，所有不能对常量N进行++操作等。

按需实例化是指：将类成员变量实例化，如果后面未使用到成员函数，则不会将函数进行实例化。

非类型模板参数和类型模板参数一样是可以给缺省值的：

3.array类

C++11库中有一个使用了非类型模板参数的类。是一个固定大小的数组。
在这里插入图片描述
可以将其理解为用一个类封装了静态数组。它支持迭代器操作。其迭代器就是俩个原生指针。
与普通的数组如:int arr[]
如果越界访问，会进严格的检测（assert断言）.
array开辟的空间在栈上，所以不能太大。
array不会进行初始化，只是把空间开辟出来。
所以我们一般使用vector<>。vector的功能已经很完善了。

三、模板typename

1.使用函数模板遍历容器

观察下面代码：

#include <iostream>
#include <vector>
using namespace std;
template<class T>
void PrintVector(const vector<T>& v)
{
vector<T>::const_iterator it = v.begin();
while (it != v.end())
{
cout << *it << ' ';
++it;
}
cout << endl;
}
int main()
{
vector<int> v1 = { 1, 2,3,4,5,6 };
vector<double> v2 = { 1.1,2.2,3.3,4.4,5.5,6.6 };
PrintVector(v1);
PrintVector(v2);
return 0;
}

代码逻辑没有问题，但是执行代码时：
在这里插入图片描述
编译报错。由于模板特性，模板不会对代码进行详细的检查，只会将模板的外壳进行检查。

这时就要对该行进typename明确告诉编译器这个是一个类型.

上图这样实例化的类就是正确的，编译器知道这一个int类型的类。

typename vector<T>::const_iterator it = v.begin();

另一种方法可以避免这一问题：

auto it = v.begin();

auto是类型，v.begin()返回什么auto就是什么。
修改之后的结果：
在这里插入图片描述

四、模板的特化

1.函数模板的特化

使用日期类Date进行举例：

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);
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>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
Date d1(2022, 10, 1);
Date d2(2022, 10, 2);
cout << Less(d1, d2) << endl;
return 0;
}

这样的代码只支持非指针和引用的比较。所以我们还需要写一个支持指针类型的模板。c++语法中我们可以对原有的模板进行特化：

template<class T>
bool Less(T left, T right)
{
return left < right;
}
// 特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}

该特化是指，其他类型模板实例化运行第一个模板，Date*类型运行第二个模板。特化就是对某个类型进行特殊处理，如果匹配到该特化就走特化版本的模板。
函数模板很容易出错：

template<class T>
bool Less(const T& left,const T& right)
{
return left < right;
}
// 特化
template<>
bool Less<Date*>(const Date*& left, const Date*& right)
{
return *left < *right;
}

在我们的理解中，将T替换成我们需要特化的类型就可以进行特殊处理，但是类似于上面的代码，稍微不细心就会出错。
在这里插入图片描述
正确的特化方式:

// 特化
template<>
bool Less<Date*>(Date* const & left, Date*const & right)
{
return *left < *right;
}

由于函数是可以重载的，所以函数模板我们尽量不使用模板特化：

bool Less(Date* const & left, Date*const & right)
{
return *left < *right;
}

2、类模板的特化

全特化

特化形式：

//类模板
template<class T1,class T2>
class Date
{
public:
Date() { cout << "Date<T1,T2>原模版" << endl; }
private:
T1 _d1;
T2 _d2;
};
//类模板特化
template<>
class Date<int, char>
{
public:
Date() { cout << "Date<int,char>全特化" << endl; }
};

int main()
{
Date<int, int> d1;
Date<int, char> d2;
return 0;
}

d2的类型为Date<int,char>符合特化的形式，实例化时执行特化版本。
代码执行结果：
在这里插入图片描述
将俩个模板参数都明确规定的特化称为全特化。

偏特化非指针类型

类似的，还有偏特化：

//类模板的偏特化
template<class T1>
class Date<T1, int>
{
public:
   Date() { cout << "Date<T1,int>偏特化" << endl; }
};

该特化的类型为：只要第二个为int的类型就执行该特化。

int main()
{
Date<int, int> d1;
Date<int, char> d2;
Date<double, int> d3;
return 0;
}

结果：
在这里插入图片描述

偏特化指针类型

如果T1,T2是指针就会施行该特化

template<class T1, class T2>
class Date<T1*, T2*>
{
public:
Date() {
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
cout << "Date<T1*,T2*>偏特化" << endl; 
}
};

注意
class Date<T1*, T2*>中T1*和T2*是其表示作用，是用于匹配，参数是否为指针，一级指针、二级指针、函数指针都是指针。
所以该特化表明如果是指针就执行该特化。
通过结果来进行观察:

int main()
{
Date<int*, int*> d1;
Date<int**, char**> d2;
Date<int**, double*> d3;
return 0;
}

在这里插入图片描述
即：

模板特化引用

和特化指针一样：

//偏特化特化引用类型
template<class T1, class T2>
class Date<T1&, T2&>
{
public:
Date() {
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
cout << "Date<T1&,T2&>偏特化" << endl; 
}
};

测试：

int main()
{
Date<int&, double&> d4;
return 0;
}

结果：
在这里插入图片描述
也可以一个引用一个指针。

五、模板的分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

模板的分离编译不能分文件

//a.h中
template<class T>
T Add(const T& left, const T& right);

//a.cpp中
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}

//主函数中
// main.cpp
#include"Template.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}

结果：
在这里插入图片描述
发生了链接错误。

编译器对模板进行处理时，在a.o中对模板只是进行外壳的维护。实例化的阶段是在编译阶段运行的
调用的地方只有声明，没有定义。
定义的地方，不知道实例化成什么。
解决方法是在定义的地方进行显示实例化：

//a.cpp中
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
template
int Add(const int& left, const int& right);
template
double Add(const double& left, const double& right);

但是显示实例化具有局限性，原本就是需要靠模板来对各个类型进行处理，我们再去显式实例化模板就失去了它的意义。

如果编译阶段，查找其他cpp文件中实例化成了什么，编译速度会大大降低。所以在模板的分离编译时，我们需要在同一个文件下进行分离。
同一个文件下，就有声明和定义在一起。就不需要进行链接，当前文件就有函数的地址。
在实际开发中，同一个文件下的声明和定义分离，在类模板中很常见。

六、模板总结

[优点]

模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
增强了代码的灵活性

[缺陷]

模板会导致代码膨胀问题，也会导致编译时间变长
出现模板编译错误时，错误信息非常凌乱，不易定位错误

如果你有所收获，可以留下的你点赞和关注,谢谢你的观看!!!

原文地址：https://blog.csdn.net/Jk_Mr/article/details/139454836

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：k8s-第十一节-Job和CronJob
下一篇：数据库基础之：函数依赖

COMSOL 声学多物理场仿真技术与应用
随着声学技术在各个领域的广泛应用，对于声学仿真的专业人才需求日益增长。Comsol 软件作为多物理场仿真的先进工具，其声学模块能够模拟声波在不同介质中的传播和交互，对于声学设计和研究具有重要意义声学仿
阅读更多2024-09-25
CF333E Summer Earnings 题解
先考虑暴力，我们先求出这些点两两之间的距离作为边，然后从大到小枚举这些边作为三角形中最短的一条边并加入图中，再枚举两个端点所连边，如果两个点有一个连边的公共点，那一定可行，且此处枚举的边即为最大值。三
阅读更多2024-09-25
每天一个数据分析题（四百七十二）- 业务角度
内容涵盖Python，SQL，统计学，数据分析理论，深度学习，可视化，机器学习，Spark八个方向的专项练习题库，数据分析从业者刷题必备神器！从业务角度区分，标签可以分为哪两类？A. 分
阅读更多2024-09-25
CentOS中使用Docker运行mysql并挂载本地目录
通过上述步骤，你就成功在 CentOS 中使用 Docker 安装了 MySQL 并将本地目录挂载到容器中的 MySQL 数据存储目录。这样可以确保数据的持久性，即使容器被删除或重新创建，数据仍然保存
阅读更多2024-09-25
lumen安装错误的解决Failed to download sebastian/recursion-context from dist
extension=zip //打开这里的开关。打开php.ini（对应版本的）
阅读更多2024-09-25
中年被裁，记录下这段时间的心路历程，内含前端面试题和面经
真正的转变都是痛苦且无声的。这段时间我经历了工作被裁员，学习复习，面试找工作，到最终找到工作。想把这段时间我的心路历程和面试题面经分享出来，说不定可以帮到你。
阅读更多2024-09-25
从入门到精通：单片机 100个关键技术关键词
无论你是电子爱好者，还是希望在这一领域深耕的专业人士，掌握单片机技术都是通往成功的关键一步。以下精选的100个关键技术关键词，将作为你从入门到精通的导航灯塔，每一步都踏在坚实的基石上，助你逐步揭开单片
阅读更多2024-09-25
MySQL—触发器详解
触发器是与表有关的数据库对象，在 INSERT、UPDATE、DELETE 操作之前或之后触发并执行触发器中定义的 SQL 语句。触发器的这种特性可以协助应用在数据库端确保数据的完整性、日志记录、数据
阅读更多2024-09-25
GPU高性能编程CUDA入门
最新版的 CMake(3.18 以上)，只需在LANGUAGES 后面加上 CUDA 即可启用。然后在 add executable 里直接加你的 .cu文件，和 .cpp 一样。CUDA和C++的关
阅读更多2024-09-25
风速预测（二）基于Pytorch的EMD-LSTM模型
本文基于前期介绍的风速数据（文末附数据集），先经过经验模态EMD分解,然后通过数据预处理，制作和加载数据集与标签，最后通过Pytorch实现EMD-LSTM模型对风速数据的预测。
阅读更多2024-09-25

C++模板进阶

文章目录

系列文章目录

一、前言

二、非类型模板参数

1.非类型模板概念

2.参数注意事项

3.array类

三、模板typename

1.使用函数模板遍历容器

四、模板的特化

1.函数模板的特化

2、类模板的特化

全特化

偏特化非指针类型

偏特化指针类型

模板特化引用

五、模板的分离编译

六、模板总结

[优点]

[缺陷]

相关文章