【C++】智能指针（RAII）详解

 

  我们在上篇文章中（异常处理详解）提到了 RAII 。那么本篇文章会对此进行详解。重点是智能指针的详解。其中会讲解到 RAII 思想、auto_ptr、unique_ptr、shared_ptr、weak_ptr、循环引用问题。希望本篇文章会对你有所帮助。

文章目录

一、为什么需要智能指针

二、智能指针的使用及原理

2、1 RAII 解释

2、2 什么是智能指针

2、3 auto_ptr

2、3、1 auto_ptr 的使用

2、3、2 auto_ptr 的模拟实现

2、4 unique_ptr

2、5 shared_ptr

三、循环引用问题及解决

3、1 weak_ptr

四、内存泄漏问题

4、1 什么是内存泄漏

4、2 内存泄漏分类

4、3 如何规避内存泄漏

🙋‍♂️ 作者：@Ggggggtm 🙋‍♂️

👀 专栏：C++ 👀

💥 标题：智能指针 💥

❣️  寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️ 

一、为什么需要智能指针

  我们先看如下一段代码：

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;
}

  上述一段简短的代码，其实隐含了许多问题。这里给出三个问题：1、如果p1这里new 抛异常会如何？2、如果p2这里new 抛异常会如何？3、如果div调用这里又会抛异常会如何？其实都会造成内存泄露。当然，我们上篇文章也讲到，可以选择异常重新抛出进行解决，但是如果 p2 内存申请失败了呢？有人说可以进行异常检查。确实可以处理。但是这仅仅只有两个动态申请指针。如果类似还有p3、p4、p5……就要进行很复杂的分情况处理。

  智能指针就可以很轻松的解决上述的情况。下面我们学习一下智能指针。

二、智能指针的使用及原理

2、1 RAII 解释

  在了解指针指针之前，我们先学习一下RAII。

  RAII，全称Resource Acquisition Is Initialization（资源获取即初始化），是一种在C++中用于管理资源的编程技术。它基于一种简单的原则，即在对象的构造函数中获得资源（例如内存、文件句柄、锁等），并在析构函数中释放这些资源。RAII采用的是C++的对象生命周期管理机制，确保在对象离开作用域时资源的正确释放，无论是通过正常流程离开还是通过异常离开。

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

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

  我们通过一段代码来理解一下：

// 使用RAII思想设计的SmartPtr类
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()
{ShardPtr<int> sp1(new int);ShardPtr<int> sp2(new int);cout << div() << endl;
}
int main()
{try {Func();}catch (const exception& e){cout << e.what() << endl;}return 0;
}

   上述代码就是把动态申请的资源交给一个类对象处理，我们只需要在该类的析构函数中对该对象进行释放即可。这样做的好处是什么呢？首先，我们不用自己手动去释放动态申请的资源。其次，即使程序出现异常崩溃了，也会将资源释放掉（类对象出了作用域会自动调用析构函数）。上述思想就是所谓了资源获取即初始化。

2、2 什么是智能指针

  传统的指针在使用过程中需要手动分配和释放内存，经常容易出现内存泄漏或者悬挂指针等问题，给程序带来安全隐患。

  智能指针是一种特殊类型的指针，它可以自动管理内存的分配和释放，为程序员提供方便和安全。智能指针通过在对象生命周期结束时自动释放指向的内存空间，减少了内存泄漏的风险。

  我们发现智能指针的概念就是采用了RAII的思想。与上面 SmartPtr 极为相似。但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容。代码如下：

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }
private:T* _ptr;
};
struct Date
{int _year;int _month;int _day;
};
int main()
{SmartPtr<int> sp1(new int);*sp1 = 10;cout << *sp1 << endl;// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->SmartPtr<Date> sparray(new Date);sparray->_year = 2018;sparray->_month = 1;sparray->_day = 1;return 0;
}

2、3 auto_ptr

  在C++中,auto_ptr是一个早期的智能指针类，用于管理动态分配的对象。它是C++98标准引入的，但已在C++11中基本上被废弃。我们来看看其使用和为什么要别弃用。

2、3、1 auto_ptr 的使用

   我们先看如下代码：

class A
{
public:~A(){cout << "~A()" << endl;}//private:int _a1 = 0;int _a2 = 0;
};int main()
{auto_ptr<A> ap1(new A);ap1->_a1++;ap1->_a2++;auto_ptr<A> ap2(ap1);ap1->_a1++;ap1->_a2++;return 0;
}

  运行结果是崩溃了，如下图：

  这是为什么呢？当将一个auto_ptr拷贝给另一个auto_ptr时，将会管理权（资源）转移（这里是指将ap1的资源转移给了ap2）。

  这个看上去好像没有什么问题，但是又好像是一个bug级别的存在。因为一不下心再去使用ap1 时，就会出现内存问题。其实底层实现也是管理权转移的思想。这也是auto_ptr现在基本上被弃用的原因了。auto_ptr 的接口含有很多，这里就不再一一解释。

  我们再看一下其底层实现。

2、3、2 auto_ptr 的模拟实现

  auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理。

	template<class T>class auto_ptr {public:auto_ptr(T* ptr = nullptr): _ptr(ptr){}auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}// ap1 = ap2;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){delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};

   注意，赋值并不只是资源转移。赋值是先将原本对象的资源进行释放，在进行资源转移。同时，在模拟实现时也需要注意是否自己和自己进行赋值。

2、4 unique_ptr

  unique_ptr 针对auto_ptr 的不足进行了调整，但是调整的有点暴力。在unique_ptr 中，直接将拷贝构造和拷贝赋值直接禁用了。

  其用法与auto_ptr 基本相似，只不过是尽禁掉了拷贝构造和拷贝赋值。我们再来看一下其底层的简单模拟实现。代码如下：

	template<class T>class unique_ptr{private:// 防拷贝 C++98// 只声明不实现 //unique_ptr(unique_ptr<T>& ap);//unique_ptr<T>& operator=(unique_ptr<T>& ap);public:unique_ptr(T* ptr = nullptr): _ptr(ptr){}// 防拷贝 C++11unique_ptr(unique_ptr<T>& ap) = delete;unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;~unique_ptr(){if (_ptr){cout << "Delete:" << _ptr << endl;delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};

  unique_ptr与auto_ptr极为相似，就不再过多解释unique_ptr。我们重点是在shared_ptr。

2、5 shared_ptr

  shared_ptr 针对之前的智能指针的问题进行了修改调整。不仅仅支持拷贝，而且也更加安全。其使用我们也不再过多详解，主要看一下其底层实现。

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

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

  那我们怎么来维护这个计数呢？首先，普通的 int 成员是不可以的。因为我们想要的时一个类对象只有一个计数。如果是普通的 int 成员，实例化每个对象都会都一个计数。

  用static 成员可不可以呢？也是不行的！我们看如下代码：

shared_ptr<A> sp1(new A);
shared_ptr<A> sp2(sp1);
shared_ptr<A> sp3(sp1);shared_ptr<int> sp4(new int);

  如果是 static 成员，那么不同类型的对象也是共享一个计数。显然这样是不正确的。

  采用一个指针可不可以呢？答案是可以的。我们采用指针时，只有在构造时，才进行申请新的指针。当采用拷贝或者赋值时，我们选择将指针进行资源转移，而不是申请新指针。这样就可以很好的控制一个类对象只有一个计数了。下面我们结合模拟实现的代码理解一下：

	template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr): _ptr(ptr), _pCount(new int(1)){}void Release(){if (--(*_pCount) == 0){cout << "Delete:" << _ptr << endl;delete _ptr;delete _pCount;}}~shared_ptr(){Release();}// sp1(sp2)shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr), _pCount(sp._pCount){(*_pCount)++;}// sp1 = sp5// sp1 = sp1// 20:16继续shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this == &sp)if (_ptr == sp._ptr){return *this;}// 减减被赋值对象的计数，如果是最后一个对象，要释放资源/*if (--(*_pCount) == 0){delete _ptr;delete _pCount;}*/Release();// 共管新资源，++计数_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;// 引用计数int* _pCount;};
}

三、循环引用问题及解决

  循环引用是指两个或多个对象之间相互引用，形成一个闭环的情况。这种情况下，由于每个对象都持有其他对象的引用计数，导致共享指针无法正确地释放内存。下面我们来看一个实际的例子：

struct Node
{int _val;std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;~Node(){cout << "~Node" << endl;}
};void test_shared_ptr2()
{std::shared_ptr<Node> n1(new Node);std::shared_ptr<Node> n2(new Node);n1->_next = n2;n2->_prev = n1;
}

  我们可以简单的理解为：双向链表中存储的是智能指针。这时候就引发了循环引用的问题。具体如下图：

  这个时候可以采用weak_ptr 来进行解决。

3、1 weak_ptr

  weak_ptr是与shared_ptr配套使用的弱引用指针。它可以解决循环引用问题，因为它不会增加内存的引用计数。我们先看一下代码：

struct Node
{int _val;/*std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;*/std::weak_ptr<Node> _next;std::weak_ptr<Node> _prev;~Node(){cout << "~Node" << endl;}
};

  _next和_prev是weak_ptr时，他不参与资源释放管理，可以访问和修改到资源，但是不增加计数，不存在循环引用的问题了。

四、内存泄漏问题

4、1 什么是内存泄漏

  内存泄漏是指在计算机程序中，通过动态分配内存空间后，无法再次释放这些空间的情况。当程序运行时，如果不再使用某段动态分配的内存空间，但没有显式地将其释放，就会导致内存泄漏的问题。

  内存泄漏可能会导致系统性能下降甚至崩溃。随着时间的推移，内存泄漏会使可用内存越来越少，最终导致程序运行失败或系统崩溃。

  在C++中，内存泄漏通常出现在以下情况下：

  1. 动态分配内存后未释放：当使用关键字new或者相关的内存分配函数（例如malloc）在堆上分配了内存空间后，如果没有调用对应的释放函数（例如delete或者free），就会发生内存泄漏。这种情况经常出现在忘记释放内存、程序异常退出等情况下。
  2. 在循环中动态分配内存未释放：当在循环中重复动态分配内存空间而未及时释放，在每次循环迭代时都会导致一次内存泄漏。 
    for (int i = 0; i < 10; i++) {int* ptr = new int; // 动态分配了一个int型的内存空间// 未在每次循环结束时释放ptr指向的内存空间，导致每次循环都有内存泄漏
}
  3. 没有正确管理对象的生命周期：当对象在不再使用时没有及时销毁或释放资源，也可能导致内存泄漏。 
    class MyClass {
public:MyClass() {buffer = new int[1000]; // 在构造函数中动态分配了一个int数组}~MyClass() {// 在析构函数中应该释放buffer指向的内存空间，但这里没有进行释放}
private:int* buffer;
};void foo() {MyClass obj;// 在此处，obj的析构函数没有被调用，导致buffer指向的内存泄漏
}

  4. 循环引用：如果两个或多个对象互相引用，并且没有其他对象引用它们，那么这些对象将无法很好的释放资源，导致内存泄漏。

  5. 异常跳转，可能会直接跳转过了释放资源的语句。也会导致内存泄漏。

4、2 内存泄漏分类

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

  • 堆内存泄漏(Heap leak)。堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏。指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

4、3 如何规避内存泄漏

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

  总的来说，内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/102225.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

MySQL 8.0.34（x64）安装笔记

MySQL 8.0.34（x64）安装笔记

一、背景 从MySQL 5.6到5.7&#xff0c;再到8.0&#xff0c;版本的跳跃不可谓不大。安装、配置的差别也不可谓不大&#xff0c;特此备忘。 二、过程 &#xff08;1&#xff09;获取MySQL 8.0社区版&#xff08;MySQL Community Server&#xff09;   从 官网 字样 “MySQL …
阅读更多...
AVLTree模拟实现

AVLTree模拟实现

一、常用的搜索逻辑 1、暴力搜索 O(N) 2、二分搜索 前提是有序&#xff0c;可以先用O(NlogN)排序一次&#xff0c;后续每次查找都是logN。 缺点&#xff1a;快排需要容器有随机访问功能&#xff0c;即为顺序表等。 如果不仅要搜索&#xff0c;还要插入删除&#xff0c;此时…
阅读更多...
Kubernetes(k8s)部署高可用多主多从的Redis集群

Kubernetes(k8s)部署高可用多主多从的Redis集群

Kubernetes部署高可用多主多从的Redis集群 环境准备准备Kubernetes准备存储类 部署redis准备一个命名空间命令创建yaml文件创建&#xff08;推荐&#xff09; 准备redis配置文件准备部署statefulset的资源清单文件执行文件完成部署初始化集群 环境准备 准备Kubernetes 首先你…
阅读更多...
解释模块化开发及其优势，并介绍常用的模块化规范。

解释模块化开发及其优势，并介绍常用的模块化规范。

聚沙成塔每天进步一点点 ⭐ 专栏简介⭐ 模块化开发⭐ 模块化开发的优势⭐ 常用的模块化规范⭐ 写在最后 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 记得点击上方或者右侧链接订阅本专栏哦 几何带你启航前端之旅 欢迎来到前端入门之旅&#xff01;这个专栏是…
阅读更多...
FPGA可重配置原理及实现（1）——导论

FPGA可重配置原理及实现（1）——导论

一、概述 可重配置技术是Xilinx提供的用来高效利用FPGA设计资源实现FPGA资源可重复利用的最新的FPGA设计技术&#xff0c;这种技术的发展为FPGA应用提供了更加广阔的前景。 术语“重构”是指FPGA已经配置后的重新编程。FPGA的重构有两种类型&#xff1a;完全的和部分的。完全重…
阅读更多...
Kafka3.0.0版本——消费者（消费者组原理）

Kafka3.0.0版本——消费者（消费者组原理）

目录 一、消费者组原理1.1、消费者组概述1.2、消费者组图解示例1.3、消费者组注意事项 一、消费者组原理 1.1、消费者组概述 Consumer Group&#xff08;CG&#xff09;&#xff1a;消费者组&#xff0c;由多个consumer组成。形成一个消费者组的条件&#xff0c;是所有消费者…
阅读更多...
Docker使用及本地Yolov5打包教程

Docker使用及本地Yolov5打包教程

1. Docker的安装 注意&#xff1a;官方也提供了直接Pull Yolov5的渠道&#xff1a; docker pull ultralytics/yolov5 详见&#xff1a;https://hub.docker.com/r/ultralytics/yolov5 --------------------------------------------------以下正文------------------------…
阅读更多...
正中优配：散户怎么实现T+0？散户在股市上怎么变相T+0？

正中优配：散户怎么实现T+0？散户在股市上怎么变相T+0？

T0是指当天买入的标的物&#xff0c;在当天就能卖出的买卖方式&#xff0c;其中&#xff0c;在a股市场上&#xff0c;散户能够通过一些办法直接地完成T0买卖方式&#xff0c;接下来&#xff0c;正中优配为大家预备了相关内容&#xff0c;以供参阅。 散户在股票市场上&#xff0…
阅读更多...
使用SpringCloud Eureka 搭建EurekaServer 集群- 实现负载均衡故障容错【上】

使用SpringCloud Eureka 搭建EurekaServer 集群- 实现负载均衡故障容错【上】

&#x1f600;前言 本篇博文是关于使用SpringCloud Eureka 搭建EurekaServer 集群- 实现负载均衡&故障容错&#xff0c;希望你能够喜欢 &#x1f3e0;个人主页&#xff1a;晨犀主页 &#x1f9d1;个人简介&#xff1a;大家好&#xff0c;我是晨犀&#xff0c;希望我的文章可…
阅读更多...
【huggingface】数据集及模型下载并保存至本地

【huggingface】数据集及模型下载并保存至本地

目录 数据集ChnSentiCorppeoples_daily_ner 模型bert-base-chinesehfl/rbt3t5-baseopus-mt-zh-enChinese_Chat_T5_Base 环境&#xff1a;没有代理&#xff0c;无法访问部分国外网络 数据集 正常情况下通过load_dataset加载数据集&#xff1b;save_to_disk保存至本地&#xff1b…
阅读更多...
Docker构建Springboot项目，并发布测试

Docker构建Springboot项目，并发布测试

把SpringBoot项目打包成Docker镜像有两种方案&#xff1a; 全自动化&#xff1a;先打好docker镜像仓库&#xff0c;然后在项目的maven配置中配置好仓库的地址&#xff0c;在项目里配置好Dockerfile文件&#xff0c;这样可以直接在idea中打包好后自动上传到镜像仓库&#xff0c…
阅读更多...
别来！这所院校性价比太低了！

别来！这所院校性价比太低了！

一、学校及专业介绍 浙江工商大学&#xff08;Zhejiang Gongshang University&#xff09;&#xff0c;简称“浙商大”&#xff08;ZJSU&#xff09;&#xff0c;坐落于浙江省杭州市&#xff0c;是中华人民共和国教育部、中华人民共和国商务部和浙江省人民政府共建的浙江省重点…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023