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

相关文章

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