【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。

相关文章

如何使用Java实现请求deepseek

如何使用Java实现请求deepseek

《如何使用Java实现请求deepseek》这篇文章主要为大家详细介绍了如何使用Java实现请求deepseek功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1.deepseek的api创建2.Java实现请求deepseek2.1 pom文件2.2 json转化文件2.2
阅读更多...
python使用fastapi实现多语言国际化的操作指南

python使用fastapi实现多语言国际化的操作指南

《python使用fastapi实现多语言国际化的操作指南》本文介绍了使用Python和FastAPI实现多语言国际化的操作指南,包括多语言架构技术栈、翻译管理、前端本地化、语言切换机制以及常见陷阱和... 目录多语言国际化实现指南项目多语言架构技术栈目录结构翻译工作流1. 翻译数据存储2. 翻译生成脚本
阅读更多...
C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...
C++ Primer 多维数组的使用

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没
阅读更多...
如何通过Python实现一个消息队列

如何通过Python实现一个消息队列

《如何通过Python实现一个消息队列》这篇文章主要为大家详细介绍了如何通过Python实现一个简单的消息队列,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录如何通过 python 实现消息队列如何把 http 请求放在队列中执行1. 使用 queue.Queue 和 reque
阅读更多...
Python如何实现PDF隐私信息检测

Python如何实现PDF隐私信息检测

《Python如何实现PDF隐私信息检测》随着越来越多的个人信息以电子形式存储和传输,确保这些信息的安全至关重要,本文将介绍如何使用Python检测PDF文件中的隐私信息,需要的可以参考下... 目录项目背景技术栈代码解析功能说明运行结php果在当今，数据隐私保护变得尤为重要。随着越来越多的个人信息以电子形
阅读更多...
使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

《使用sql-research-assistant进行SQL数据库研究的实战指南(代码实现演示)》本文介绍了sql-research-assistant工具,该工具基于LangChain框架,集... 目录技术背景介绍核心原理解析代码实现演示安装和配置项目集成LangSmith 配置（可选）启动服务应用场景
阅读更多...
使用Python快速实现链接转word文档

使用Python快速实现链接转word文档

《使用Python快速实现链接转word文档》这篇文章主要为大家详细介绍了如何使用Python快速实现链接转word文档功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 演示代码展示from newspaper import Articlefrom docx import
阅读更多...
前端原生js实现拖拽排课效果实例

前端原生js实现拖拽排课效果实例

《前端原生js实现拖拽排课效果实例》：本文主要介绍如何实现一个简单的课程表拖拽功能,通过HTML、CSS和JavaScript的配合,我们实现了课程项的拖拽、放置和显示功能,文中通过实例代码介绍的... 目录1. 效果展示2. 效果分析2.1 关键点2.2 实现方法3. 代码实现3.1 html部分3.2
阅读更多...
Java深度学习库DJL实现Python的NumPy方式

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2