【C++干货铺】 RAII实现智能指针

2024-01-25 01:44
文章标签 c++ 实现 指针 智能 干货 raii

本文主要是介绍【C++干货铺】 RAII实现智能指针，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

=========================================================================

个人主页点击直达：小白不是程序媛

C++系列专栏：C++干货铺

代码仓库：Gitee

=========================================================================

目录

为什么需要智能指针？

内存泄漏

        什么是内存泄漏，内存泄露的危害

内存泄漏的分类

堆内存泄漏（Heap leak）

系统资源泄露

如何避免内存泄漏

智能指针的使用及原理

RAII

智能指针的原理

std::auto_ptr

std::unipue_ptr

 std::shared_ptr

std::shared_ptr的循环引用

定制删除器

为什么需要智能指针？

下面我们先分析一下下面这段程序有没有什么内存方面的问题？

int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{// 1、如果p1这里new 抛异常会如何？// 2、如果p2这里new 抛异常会如何？// 3、如果div调用这里又会抛异常会如何？int* p1 = new int;int* p2 = new int;cout << div() << endl;delete p1;delete p2;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

注：如果我们输入的被除数不等于0这种情况没什么问题。调用Func()函数动态开辟两块空间，调用div()函数，div()函数正常返回；Func()函数调用结束，没有异常整个main()函数调用结束。当我们的被除数等于0时，就会存在内存泄漏。被除数输入0时，div()函数就会抛出异常；在main函数中这个异常被捕捉；程序调用结束。然而在div函数调用之前，我们动态开辟了两块空间没有被释放就会造成内存泄漏。因此我们就要解决这个问题，其实在异常那篇文章中我们已经给出了解决方案：就是连续的捕捉异常。也可以使用本篇文章中介绍的智能指针。

内存泄漏

什么是内存泄漏，内存泄露的危害

什么是内存泄漏：

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{// 1.内存申请了忘记释放int* p1 = (int*)malloc(sizeof(int));int* p2 = new int;// 2.异常安全问题int* p3 = new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放delete[] p3;
}

内存泄漏的分类

C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏（Heap leak）

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄露

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

  • 1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  • 2. 采用RAII思想或者智能指针来管理资源。
  • 3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  • 4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵

内存泄漏非常常见，解决方案分为两种：

  • 1、事前预防型。如智能指针等。
  • 2、事后查错型。如泄漏检测工具。

智能指针的使用及原理

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。

就像上面的问题我们可以使用RAII的思想解决

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}private:T* _ptr;
};
int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{SmartPtr<int> sp1(new int);SmartPtr<int> sp2(new int);cout << div() << endl;
}
int main()
{try {Func();}catch (const exception& e){cout << e.what() << endl;}return 0;
}

智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其
像指针一样去使用。

总结一下智能指针的原理：

  • 1. RAII特性
  • 2. 重载operator*和opertaor->，具有像指针一样的行为。

std::auto_ptr

std::auto_ptr文档介绍

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份auto_ptr来了解它的原
理

namespace L
{template<class T>class auto_ptr{public:auto_ptr( T* ptr):_ptr(ptr){}auto_ptr( auto_ptr<T>& ap):_ptr(ap._ptr){//管理权转移ap._ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T> ap){//检测是否自己为自己赋值if (this != ap){//释放当前对象中的资源if (_ptr)delete _ptr;//转移资源_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}//重载* 和 -> 操作符 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}
int main()
{L::auto_ptr<int> ap1(new int);L::auto_ptr<int> ap2 = ap1;// 管理权转移，导致对象悬空(*ap1)++;(*ap2)++;
}

总结：auto_ptr是一个失败的设计，拷贝构造获知复制重载后会使原来的对象悬空。

std::unipue_ptr

基于auto_ptr的失败，C++11中开始提供更靠谱的unique_ptr

unique_ptr文档介绍

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理

//unique_ptr
namespace LT
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//将拷贝构造和赋值重载使用delete关键字删除unique_ptr(const unique_ptr<T>& sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;private://C98中也可以将拷贝构造和复制重载私有化/*unique_ptr(const unique_ptr<T>& up);unique_ptr<T>& operator=(const unique_ptr<T>& up);*/T* _ptr;};}
int main()
{LT::unique_ptr<int> up1(new int(1));//LT::unique_ptr<int> up2 = up1;LT::unique_ptr<int> up3(new int(2));//up1 = up3;
}

 

 

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

std::shared_ptr文档介绍

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共
享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减
一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

下面简化模拟实现了一份shared_ptr来了解它的原理

namespace LTC
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){++(*_pcount);}shared_ptr<T>& operator=(const shared_ptr<T>& sp){//判断是不是自己重载自己if (_ptr != sp._ptr){//判断自己指向的资源应不应该释放if (--(*_pcount) == 0){delete _ptr;delete _pcount;}//改变指向 和计数器_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}~shared_ptr(){//当计数器减减等于0时释放资源if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private://指向开辟的空间T* _ptr ;//计数int* _pcount ;};
}

std::shared_ptr的循环引用

shared_ptr确实解决了不能拷贝的问题，但是却引出了新的问题——循环引用。

struct ListNode
{int _data;shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

循环引用分析： 

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手delete。
2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上
一个节点。
4. 也就是说_next析构了，node2就释放了。
5. 也就是说_prev析构了，node1就释放了。
6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

	template<class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};	
struct ListNode{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }};
int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

解决方案：

在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

定制删除器

上面的问题我们都是new一个对象，要是我们new一堆对象，而析构只能析构一个这怎么办呢？

namespace LTC
{template<class T>class shared_ptr{public:// RAIIshared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)){}template<class D>shared_ptr(T* ptr, D del): _ptr(ptr), _pcount(new int(1)), _del(del){}// function<void(T*)> _del;void release(){if (--(*_pcount) == 0){//cout << "delete->" << _ptr << endl;//delete _ptr;_del(_ptr);delete _pcount;}}~shared_ptr(){release();}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);}// sp1 = sp3shared_ptr<T>& operator=(const shared_ptr<T>& sp){if (_ptr != sp._ptr){release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count() const{return *_pcount;}T* get() const{return _ptr;}private:T* _ptr;int* _pcount;function<void(T*)> _del = [](T* ptr) {delete ptr; };};
template<class T>
class DelArray
{
public:void operator()(T* ptr){delete[] ptr;}
};
void test_shared_ptr4()
{// 定制删除器LTC::shared_ptr<ListNode> sp1(new ListNode[10], DelArray<ListNode>());LTC::shared_ptr<ListNode> sp2(new ListNode[10], [](ListNode* ptr) {delete[] ptr; });//LTC::shared_ptr<FILE> sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {fclose(ptr); });LTC::shared_ptr<ListNode> sp4(new ListNode);
}

在类成员中增加一个包装器，默认包装释放一个数据的lambda表达式；当动态开辟一组数据时候我们就要使用释放一组数据的方法（lambda表达式，仿函数）和默认的包装器发生重载，当动态开辟一个数据时候，直接使用默认释放一个数据的包装器。 

 今天给大家分享介绍了C++中的智能指针。如果觉得文章还不错的话，可以三连支持一下，个人主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的三连支持就是我前进的动力！

这篇关于【C++干货铺】 RAII实现智能指针的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/641711。

相关文章

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
嵌入式QT开发：构建高效智能的嵌入式系统

嵌入式QT开发：构建高效智能的嵌入式系统

摘要： 本文深入探讨了嵌入式 QT 相关的各个方面。从 QT 框架的基础架构和核心概念出发，详细阐述了其在嵌入式环境中的优势与特点。文中分析了嵌入式 QT 的开发环境搭建过程，包括交叉编译工具链的配置等关键步骤。进一步探讨了嵌入式 QT 的界面设计与开发，涵盖了从基本控件的使用到复杂界面布局的构建。同时也深入研究了信号与槽机制在嵌入式系统中的应用，以及嵌入式 QT 与硬件设备的交互，包括输入输出设
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯，先赞后看哦~🎈🎈 🏆 作者简介：景天科技苑 🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。 🏆《博客》：Python全栈，前后端开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi
阅读更多...
让树莓派智能语音助手实现定时提醒功能

让树莓派智能语音助手实现定时提醒功能

最初的时候是想直接在rasa 的chatbot上实现，因为rasa本身是带有remindschedule模块的。不过经过一番折腾后，忽然发现，chatbot上实现的定时，语音助手不一定会有响应。因为，我目前语音助手的代码设置了长时间无应答会结束对话，这样一来，chatbot定时提醒的触发就不会被语音助手获悉。那怎么让语音助手也具有定时提醒功能呢？ 我最后选择的方法是用threading.Time
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2