【C++】一篇文章带你熟练掌握＜智能指针＞及其模拟实现

2024-05-05 23:12
文章标签 c++ 实现 指针 模拟 智能 文章 一篇 熟练掌握

本文主要是介绍【C++】一篇文章带你熟练掌握＜智能指针＞及其模拟实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

一、引入

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

1、RAII

2、智能指针的原理

3、auto_ptr

4、unique_ptr

5、shared_ptr

6、weak_ptr 

一、引入

我们先分析一下为什么需要智能指针？

double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0){throw invalid_argument("Division by zero condition!");}return (double)a / (double)b;
}void Func()
{int* p = new int[10];int len, time;cin >> len >> time;cout << Division(len, time) << endl;delete p;cout << "delete[]"<<p << endl;
}int main()
{try{Func();}catch (const exception& e){cout << e.what() << endl;}return 0;
}

当正常使用时，可以正常释放（delete）空间

 这里会使用异常处理，当div函数抛异常时，就会直接跳到catch捕获的地方，进行处理。​

在 new 和 delete 之间如果 div() 抛异常了，那么开辟的空间 p 就无法释放。最终会造成内存泄露。我们之前面对这样的问题，是对 div() 函数套一层异常判断，如果出现异常，先释放资源，再将异常抛出给外面的捕获处理【异常处理】。但是这样还是会有缺陷，如果有很多个资源申请呢?或者有连续的资源申请呢？比如资源1申请，如果出现异常，那么就直接跳出去，如果资源2异常那么就需要对这个操作套一层异常处理，需要先将资源1的资源释放了，然后再重新抛异常给外面。这样是不是每次申请资源时都需要套上异常处理呢？这样也太麻烦了吧！因此 C++ 为了解决这个问题，发明了智能指针。

使用智能指针出了作用域可以正常调用析构函数

class SmartPtr
{
public:SmartPtr(int* ptr):_ptr(ptr){}~SmartPtr(){delete[] _ptr;cout << "delete[] " << _ptr << endl;}
private:int* _ptr;
};double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0){throw invalid_argument("Division by zero condition!");}return (double)a / (double)b;
}void Func()
{int* p = new int[10];SmartPtr sp(p);int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}int main()
{try{Func();}catch (const exception& e){cout << e.what() << endl;}return 0;
}

​​

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

1、RAII

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

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
template<class T>
class SmartPtr
{
public:// RAIISmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){delete[] _ptr;cout << "delete[] " << _ptr << endl;}
private:T* _ptr;
};double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0){throw invalid_argument("Division by zero condition!");}return (double)a / (double)b;
}void Func()
{// RAII//这里再怎么抛异常都不会影响资源的释放，因为资源是被智能指针对象管理着//当对象销毁时，管理的资源肯定会释放的。SmartPtr<int> sp1(new int[10]);SmartPtr<double> sp2(new double[10]);int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}int main()
{try{Func();}catch (const exception& e){cout << e.what() << endl;}return 0;

2、智能指针的原理

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

重载这些运算符之前已经写过很多次，这里就不再赘述了~

template<class T>
class SmartPtr
{
public:// RAIISmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){cout << "~SmartPtr()->" << _ptr << endl;delete _ptr;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

3、auto_ptr

一般正常使用智能指针，就可以避免大多数的内存泄露问题，但不排除乱用的。智能指针的应用能帮助我们很好的处理因为异常出现而导致的内存泄露问题。不过初期的智能指针还存在着问题，比如拷贝问题。C++98时期就已经存在智能指针 auto_ptr.(C++ 98的 auto_ptr 被吐槽众多，被很多公司所禁用）

    // C++98// 管理权转移，最后一个拷贝对象管理资源，被拷贝对象都被置空// 很多公司都明确规定了，不要用这个template<class T>class auto_ptr{public:// RAIIauto_ptr(T* ptr):_ptr(ptr){}~auto_ptr(){if (_ptr){cout << "delete->" << _ptr << endl;delete _ptr;_ptr = nullptr;}}// ap2(ap1)auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};

C++98的 auto_ptr 智能指针，处理这种问题的原理是：管理权转移。
什么叫管理权转移呢？就比如ap2(ap1)，将ap1拷贝给ap2,也就是用ap1构造ap2。首先我们要明白，ap1是管理着一块资源的，ap2还没有实例化，没有管理资源。这里直接将ap1管理资源的权力转移给ap2。然后ap1就没有权力管理资源了也就是不需要管理资源了。不管理资源是如何做到的呢？直接将智能指针对象里面的指针置空即可 

【总结】

拷贝时，会把被拷贝对象的资源管理转移给拷贝对象。而被被拷贝对象就没有资源管理，直接置空

存在问题：管理权转移后，再次访问被拷贝对象

ap1这个智能指针已经没有资源可以管理了，里面的指针直接置空了，不能再访问了

指针之间的拷贝肯定是值拷贝，因为是内置类型，不存在深拷贝。那浅拷贝我们不写，编译器生成的拷贝构造就是浅拷贝，但是如果指针浅拷贝了，就会出现这样的问题：①指向同一块的空间被释放两次②有一块空间没有释放，内存泄露。 

这个版本被吐槽的很多，因为你将ap1对象管理资源的权转移后，ap1就悬空了。如果有人要再次访问ap1呢？这时就会出现问题。(里面的指针必须置空，不然就会释放两次。)

4、unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，利用delete关键字，将函数定义为删除函数，不能使用。指针赋值的操作也被禁止。

    // C++11 template<class T>class unique_ptr{public:// RAIIunique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){cout << "delete->" << _ptr << endl;delete _ptr;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}// C++11unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;private:// C++98// 1、只声明不实现// 2、限定为私有//unique_ptr(const unique_ptr<T>& up);//unique_ptr<T>& operator=(const unique_ptr<T>& up);private:T* _ptr;};

5、shared_ptr

但是如果就是存在智能指针间的拷贝，那该怎么办呢？unique_ptr肯定不能使用了。
所以C++11又提供了一个可以允许拷贝的智能指针，那就是 shared_ptr.

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

实现原理：<引用计数>

🟢 shared_ptr 在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。

🟢 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。

🟢如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

🟢 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

我们想要的计数器应该是要伴随着资源的申请而生成。当有一个资源生成被智能指针管理后，就会生成一个计数器，来计算该资源受管理的个数。当有两个资源时，就会有两个计数器，各计算各的，互不影响。所以这里的计数器应该是动态计数器。
当有资源申请时并给对象管理时(也就是调用对象的构造函数)时，就会动态生成一个计数器。

 

 shared_ptr 除了支持智能指针间的拷贝，还支持指针间的赋值。那么赋值重载是如何实现的呢？
首先赋值是两个都已经存在的对象进行赋值。而拷贝构造是已存在的拷贝给不存在的对象。假设两个存在的对象，各自都管理着一块资源，当两个对象进行赋值

  • 如果将sp3 赋值给 sp1，那么sp1 对象的指针和计数器指针都要指向sp3所指向的资源和计数器。
  • sp1对象管理的资源少了一个，所以计算器 -1；
  • sp3对象管理的资源多了一个，所以计算器 +1；

  • 同时还必须考虑到赋值对象的计数器减减后，需要进行判断，是否为0.如果计数器为0了，就说明该资源上没有对象管理，那么该资源就可以释放了。如下方的sp3 = sp1

  • 如果自己赋值给自己，可能会导致计数器 -1  为0，释放掉指向的资源，我们为了避免这种类型的发生，如果有自己赋值给自己的情况，直接返回 *this 即可
template<class T>class shared_ptr{public:// RAIIshared_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();}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;};

6、weak_ptr 

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

循环引用分析：

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

首先我们需要明白引起循环计数的原因是什么，要理解什么场景下会发生循环计数。

  • 因为智能指针定义在节点的内部。
  • 因为计数器要等于1时才可以释放资源。

就是因为内部的智能指针参与了资源的管理，导致计数器增加，外面管理的资源的对象销毁后资源也无法销毁，需要里面的智能指针对象销毁才可以销毁，而里面的对象销毁又需要资源先销毁才可以销毁。所以最主要原因就是内部的智能指针管理资源。
所以 weak_ptr 实现的原理就是让节点里面的智能指针不管理资源，就单纯的链接节点，不参与资源的管理，但可以访问资源。
这样计数器就不会增加，当外面的对象销毁，资源就会正常销毁。

【解决方案】在引用计数的场景下，把节点中的_prev和_next 改成 weak_ptr 就可以了

【解决原理】node1->_next = node2; 和node2->_prev = node1;时weak_ptr的_next和 _prev不会增加node1和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;};

这篇关于【C++】一篇文章带你熟练掌握＜智能指针＞及其模拟实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

Linux下删除乱码文件和目录的实现方式

Linux下删除乱码文件和目录的实现方式

《Linux下删除乱码文件和目录的实现方式》：本文主要介绍Linux下删除乱码文件和目录的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux下删除乱码文件和目录方法1方法2总结Linux下删除乱码文件和目录方法1使用ls -i命令找到文件或目录
阅读更多...
SpringBoot+EasyExcel实现自定义复杂样式导入导出

SpringBoot+EasyExcel实现自定义复杂样式导入导出

《SpringBoot+EasyExcel实现自定义复杂样式导入导出》这篇文章主要为大家详细介绍了SpringBoot如何结果EasyExcel实现自定义复杂样式导入导出功能,文中的示例代码讲解详细,... 目录安装处理自定义导出复杂场景1、列不固定，动态列2、动态下拉3、自定义锁定行/列，添加密码4、合并
阅读更多...
mybatis执行insert返回id实现详解

mybatis执行insert返回id实现详解

《mybatis执行insert返回id实现详解》MyBatis插入操作默认返回受影响行数,需通过useGeneratedKeys+keyProperty或selectKey获取主键ID,确保主键为自... 目录 两种方式获取自增 ID：1. ​​useGeneratedKeys+keyProperty（推
阅读更多...
Spring Boot集成Druid实现数据源管理与监控的详细步骤

Spring Boot集成Druid实现数据源管理与监控的详细步骤

《SpringBoot集成Druid实现数据源管理与监控的详细步骤》本文介绍如何在SpringBoot项目中集成Druid数据库连接池,包括环境搭建、Maven依赖配置、SpringBoot配置文件... 目录1. 引言1.1 环境准备1.2 Druid介绍2. 配置Druid连接池3. 查看Druid监控
阅读更多...
Linux在线解压jar包的实现方式

Linux在线解压jar包的实现方式

《Linux在线解压jar包的实现方式》：本文主要介绍Linux在线解压jar包的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux在线解压jar包解压 jar包的步骤总结Linux在线解压jar包在 Centos 中解压 jar 包可以使用 u
阅读更多...
Python办公自动化实战之打造智能邮件发送工具

Python办公自动化实战之打造智能邮件发送工具

《Python办公自动化实战之打造智能邮件发送工具》在数字化办公场景中,邮件自动化是提升工作效率的关键技能,本文将演示如何使用Python的smtplib和email库构建一个支持图文混排,多附件,多... 目录前言一、基础配置：搭建邮件发送框架1.1 邮箱服务准备1.2 核心库导入1.3 基础发送函数二、
阅读更多...
c++ 类成员变量默认初始值的实现

c++ 类成员变量默认初始值的实现

《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录C++类成员变量初始化c++类的变量的初始化在C++中，如果使用类成员变量时未给定其初始值，那么它将被
阅读更多...
C++中NULL与nullptr的区别小结

C++中NULL与nullptr的区别小结

《C++中NULL与nullptr的区别小结》本文介绍了C++编程中NULL与nullptr的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编... 目录C++98空值——NULLC++11空值——nullptr区别对比示例 C++98空值——NUL
阅读更多...
C++ Log4cpp跨平台日志库的使用小结

C++ Log4cpp跨平台日志库的使用小结

《C++Log4cpp跨平台日志库的使用小结》Log4cpp是c++类库,本文详细介绍了C++日志库log4cpp的使用方法,及设置日志输出格式和优先级,具有一定的参考价值,感兴趣的可以了解一下... 目录一、介绍1. log4cpp的日志方式2.设置日志输出的格式3. 设置日志的输出优先级二、Window
阅读更多...
Qt使用QSqlDatabase连接MySQL实现增删改查功能

Qt使用QSqlDatabase连接MySQL实现增删改查功能

《Qt使用QSqlDatabase连接MySQL实现增删改查功能》这篇文章主要为大家详细介绍了Qt如何使用QSqlDatabase连接MySQL实现增删改查功能,文中的示例代码讲解详细,感兴趣的小伙伴... 目录一、创建数据表二、连接mysql数据库三、封装成一个完整的轻量级 ORM 风格类3.1 表结构
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2