0
0

智能指针（解决你的内存泄漏）

智能指针

1、为什么需要智能指针？

我们先来看一段代码，注意观察有什么问题？

intdiv(){int n, m;
    cin >> n >> m;if(m ==0)throwstring("除0错误");return n / m;}voidfun(){int* p =newint;
    cout <<div()<< endl;/*try
    {
        cout << div() << endl;
    }
    catch (...)
    {
        cout << "delete" << p << endl;
        delete p;
        throw;
    }*/
    cout <<"delete"<< p << endl;delete p;}intmain(){try{fun();}catch(const string& e){
        cout << e << endl;}return0;}

如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。

看了上一篇博客异常的同学，一眼就看得出来，p没有得到释放。异常中，是通过重新抛出解决释放的。异常安全问题。但如果没有抛异常那？

比如，我们经常用new、malloc、fopen，还有抛异常，但是忘记delete、free、fclose，这又该如何处理？这时就需要用到智能指针。在学会使用智能指针之前，我们先来具体了解一下内存泄漏。

2、内存泄漏

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

  1. 什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
  2. 内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死
voidMemoryLeaks(){1.内存申请了忘记释放
    int* p1 =(int*)malloc(sizeof(int));int* p2 =newint;2.异常安全问题
    int* p3 =newint[10];Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.delete[] p3;}

2.2 内存泄漏分类（了解）

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

  • 堆内存泄漏(Heap leak)

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

小本本记下来：
这里指的就是Linux中进程的进程地址空间，其中的堆没有得到相应的释放。提到这里，我们知道在vs下，写一段代码，开辟一块空间，然后没有释放，为什么最后程序结束就释放了。原因就是该进程执行结束，对应进程地址空间中的堆空间得到了释放。

  • 系统资源泄漏

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

2.3 如何检测内存泄漏（了解）

  • 在linux下内存泄漏检测：linux下几款内存泄漏检测工具
  • 在windows下使用第三方工具：VLD工具说明
  • 其他工具：内存泄漏工具比较

Linux下比较出门的内存泄漏检查工具就是valgrind

2.4 如何避免内存泄漏

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

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

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

上面我们已经知道了内存泄漏的原理，和解决办法，接下来我们来学习智能指针的一个使用及原理。

3.1 RAII

我们先来看一段代码，看看智能指针如何解决内存泄漏问题。

// RAII + 像指针一样template<classT>classSmartPtr{public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){if(_ptr){
            cout <<"delete:"<< _ptr << endl;delete _ptr;
            _ptr =nullptr;}}private:
    T* _ptr;};intmain(){//把new int委托给sp1对象，构造时获取资源，析构时释放资源
    SmartPtr<int>sp1(newint);*sp1 =10;//在比如给键值对
    SmartPtr<pair<int,int>>sp2(new pair<int,int>);
    sp2->first =111;
    sp2->second =222;return0;}

把开辟的空间给一个对象，构造时获取资源，析构时释放资源，达到解决内存泄漏的问题。
在这里插入图片描述
上面，可能看起来不是那么明显，下面再利用malloc来看一下。
在这里插入图片描述

tmp指针给了sp对象，则在sp的生命周期结束之前，tmp的资源也都有效，即将一块开辟的空间交给了—个对象，由这个对象来掌管获取资源和释放资源（就比如你的钱就是你女朋友管着的，她你要用就给你，她说你不能用就不给你，管着你，直到你…）。

3.2 智能指针的原理

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

template<classT>classSmartPtr{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;};intmain(){
    SmartPtr<int>sp1(newint);*sp1 =10;
    cout <<*sp1 << endl;
    SmartPtr<Date>sparray(new Date);// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    sparray->_year =2018;
    sparray->_month =1;
    sparray->_day =1;}

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

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

3.3 std::auto_ptr（C++98）

C++98版本的库中就提供了auto_ptr的智能指针。但是atuo_ptr存在一些问题，下面来看看代码，在具体分析。

#include<memory>classDate{public:Date(){ cout <<"Date()"<< endl;}~Date(){ cout <<"~Date()"<< endl;}int _year;int _month;int _day;};intmain(){
    auto_ptr<Date>ap(new Date);
    auto_ptr<Date>copy(ap);// auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了// C++98中设计的auto_ptr问题是非常明显的，所以实际中很多公司明确规定了不能使用auto_ptr
    ap->_year =2018;return0;}

拷贝构造或者赋值后，ap对象悬空，变为空指针，此时再去使用ap，自然会报错，这就是auto_ptr的弊端。
在这里插入图片描述
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份AutoPtr来了解它的原理

// 模拟实现一份简答的AutoPtr,了解原理template<classT>classAutoPtr{public:AutoPtr(T* ptr =NULL):_ptr(ptr){}~AutoPtr(){if(_ptr)delete _ptr;}// 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，// 这样就解决了一块空间被多个对象使用而造成程序奔溃问题AutoPtr(AutoPtr<T>& ap):_ptr(ap._ptr){
        原对象悬空了
        ap._ptr =NULL;}
    AutoPtr<T>&operator=(AutoPtr<T>& ap){// 检测是否为自己给自己赋值if(this!=&ap){// 释放当前对象中资源if(_ptr)delete _ptr;// 转移ap中资源到当前对象中
            _ptr = ap._ptr;
            悬空
            ap._ptr =NULL;}return*this;}
    T&operator*(){return*_ptr;}
    T*operator->(){return _ptr;}private:
    T* _ptr;};

上面就是auto_ptr的原理，拷贝构造或者赋值时，将复制的对象的资源置空。

3.4 std::unique_ptr（C++11）

unique_ptr设计的原理就是防拷贝，也就是不让拷贝和赋值，也就不存在悬空的问题。

// 模拟实现一份简答的UniquePtr,了解原理template<classT>classUniquePtr{public:UniquePtr(T * ptr =nullptr):_ptr(ptr){}~UniquePtr(){if(_ptr)delete _ptr;}
    T&operator*(){return*_ptr;}
    T*operator->(){return _ptr;}private:// C++98防拷贝的方式：只声明不实现+声明成私有UniquePtr(UniquePtr<T>const&);
    UniquePtr &operator=(UniquePtr<T>const&);// C++11防拷贝的方式：delete   就是禁止生成拷贝构造和赋值重载UniquePtr(UniquePtr<T>const&)=delete;
    UniquePtr &operator=(UniquePtr<T>const&)=delete;private:
    T * _ptr;};

缺陷：如果有需要拷贝的场景就没法使用

3.5 std::shared_ptr（C++11，稳定，可拷贝）

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

struct Date
{int _year;int _month;int _day;};intmain(){// shared_ptr通过引用计数支持智能指针对象的拷贝
    shared_ptr<Date>sp(new Date);
    shared_ptr<Date>copy(sp);
    cout <<"ref count:"<< sp.use_count()<< endl;
    cout <<"ref count:"<< copy.use_count()<< endl;return0;}

在这里插入代码片
shared_ptr原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
模拟实现一下
namespace bit
{template<classT>classSharedPtr{public:SharedPtr(T* ptr =nullptr):_ptr(ptr),_pRefCount(newint(1)){}~SharedPtr(){Release();}SharedPtr(const SharedPtr<T>& sp):_ptr(sp._ptr),_pRefCount(sp._pRefCount){++(*_pRefCount);}// sp1 = sp2
        SharedPtr<T>&operator=(const SharedPtr<T>& sp){//if (this != &sp)if(_ptr != sp._ptr){// 释放管理的旧资源Release();// 共享管理新对象的资源，并增加引用计数
                _ptr = sp._ptr;
                _pRefCount = sp._pRefCount;++(*_pRefCount);}return*this;}
        T&operator*(){return*_ptr;}
        T*operator->(){return _ptr;}intUseCount(){return*_pRefCount;}
        T*Get(){return _ptr;}private:voidRelease(){// 引用计数减1，如果减到0，则释放资源if(--(*_pRefCount)==0){delete _ptr;delete _pRefCount;
                cout <<"资源释放了"<< endl;
                _ptr = nulltpr;
                _pRefCount =nullptr;}}private:int* _pRefCount;// 引用计数   注意这里不能写成引用，外面可以更改值，不安全
        T* _ptr;// 指向管理资源的指针};}intmain(){
    bit::SharedPtr<int>sp1(newint(10));
    bit::SharedPtr<int>sp2(sp1);return0;}

在这里插入图片描述
我们可以看到，*_pRefCount = 0就释放了该资源。
在这里插入图片描述
我们再看看赋值重载

bit::SharedPtr<int>sp3(newint);
bit::SharedPtr<int>sp4(sp3);
bit::SharedPtr<int>sp5(sp3);
sp1 = sp4;资源转移
//资源转移，对应sp1的pRefCount--,所以sp2的奇数变成了1，sp1此时与sp4共享资源，计数也就变成了4

这里可以看到sp2的计数变成了1，因为此时sp1和sp4共享资源，sp4对应的计数就++，sp2此时就sp2一个对象，所以计数为1。
在这里插入图片描述

shared_ptr 的线程安全问题

shared_ptr的线程安全问题：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
bit::SharedPtr<int>sp(newint);
cout << sp.UseCount()<< endl;
有可能不会出现线程安全问题，将n改大概率会提升
int n =10000;//线程安全问题，谁先构造，后析构，顺序随机的，这里需要加锁，保证安全 
thread t1([&](){for(int i =0; i < n;++i)
            bit::SharedPtr<int>sp1(sp);});
thread t2([&](){for(int i =0; i < n;++i)
            bit::SharedPtr<int>sp2(sp);});
t1.join();
t2.join();
cout << sp.UseCount()<< endl;

在这里插入图片描述
通过运行结果，我们可以得知，其结果是不确定的，因为两个线程在互相争夺资源，pRefCount++还是–，我们是无法得知的，有可能还会崩溃，所以我们需要加锁防止这样的错误。

namespace dy
{template<classT>classshared_ptr{public:shared_ptr(T* ptr =nullptr):_ptr(ptr),_pcount(newint(1)),_pmtx(new mutex){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx){add_ref_count();}// sp1 = sp4
        shared_ptr<T>&operator=(const shared_ptr<T>& sp){if(this!=&sp){// 减减引用计数，如果我是最后一个管理资源的对象，则释放资源release();// 我开始跟你一起管理资源
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                _pmtx = sp._pmtx;add_ref_count();}return*this;}voidadd_ref_count(){//加锁或者使用++的原子操作
            _pmtx->lock();++(*_pcount);
            _pmtx->unlock();}voidrelease(){bool flag =false;
            _pmtx->lock();if(--(*_pcount)==0){if(_ptr){
                    cout <<"delete:"<< _ptr << endl;delete _ptr;
                    _ptr =nullptr;}delete _pcount;
                _pcount =nullptr;
                flag =true;}
            _pmtx->unlock();if(flag ==true){delete _pmtx;
                _pmtx =nullptr;}}~shared_ptr(){release();}intuse_count(){return*_pcount;}
        T*get_ptr()const{return _ptr;}
        T&operator*(){return*_ptr;}
        T*operator->(){return _ptr;}private:
        T* _ptr;// 记录有多少个对象一起共享管理资源，最后一个析构释放资源int* _pcount;
        mutex* _pmtx;//互斥锁};}

在这里插入图片描述
通过运行结果可以看到，使用了锁之后，保证了线程安全。

shared_ptr的缺陷（循环引用）

struct ListNode
{int _data;
    dy::shared_ptr<ListNode> _next;
    dy::shared_ptr<ListNode> _prev;~ListNode(){ cout <<"~ListNode()"<< endl;}};intmain(){
    dy::shared_ptr<ListNode>node1(new ListNode);
    dy::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;return0;}

在这里插入图片描述
通过运行结果，我们可以得知，这两个结点都没有释放，具体原因是什么？
在这里插入图片描述
循环引用分析：

  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成员，所以这就叫循环引用，谁也不会释放。

简单来说：就是互相指着，你不松口，我绝不松口，势不两立的样子。

weak_ptr（解决循环引用的问题）

我们可以通过weak_ptr指针去解决循环引用的问题。严格来说weak_ptr不是智能指针，因为他没有RAII资源管理机制。

// 严格来说weak_ptr不是智能指针，因为他没有RAII资源管理机制// 专门解决shared_ptr的循环引用问题template<classT>classweak_ptr{public:weak_ptr()=default;weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get_ptr()){}

    weak_ptr<T>&operator=(const shared_ptr<T>& sp){
        _ptr = sp.get_ptr();//直接去获得shared_ptr的共享地址，不用引用计数return*this;}

    T&operator*(){return*_ptr;}

    T*operator->(){return _ptr;}private:
    T* _ptr;};struct ListNode
{int _data;
    dy::weak_ptr<ListNode> _next;
    dy::weak_ptr<ListNode> _prev;~ListNode(){ cout <<"~ListNode()"<< endl;}};intmain(){
    dy::shared_ptr<ListNode>node1(new ListNode);
    dy::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;return0;}

在这里插入图片描述

删除器（了解）

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题

// 仿函数的删除器template<classT>struct FreeFunc {voidoperator()(T* ptr){
        cout <<"free:"<< ptr << endl;free(ptr);}};template<classT>struct DeleteArrayFunc {voidoperator()(T* ptr){
        cout <<"delete[]"<< ptr << endl;delete[] ptr;}};intmain(){
    FreeFunc<int> freeFunc;
    shared_ptr<int>sp1((int*)malloc(4), freeFunc);//就是通过仿函数来释放资源
    DeleteArrayFunc<int> deleteArrayFunc;
    shared_ptr<int>sp2(newint[10], deleteArrayFunc);return0;}

本质就是通过仿函数来删除资源，这里知道是这个原理就行。

总结

C++11和boost中智能指针的关系

  1. C++ 98 中产生了第一个智能指针auto_ptr（不适用）.
  2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
  3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的
标签： c++ 开发语言 后端
本文转载自: https://blog.csdn.net/weixin_46873777/article/details/123279167
版权归原作者 雨轩（爵丶迹） 所有， 如有侵权，请联系我们删除。
登录后发布评论

“智能指针（解决你的内存泄漏）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

前端安全——敏感信息泄露

Python_PyCharm_Turtle-执行绘图代码时报错Tcl插件未识别或未安装等解决方案

探索开源语音识别的未来：高效利用先进的自动语音识别技术20241030

kafka

MySQL 删除数据库

深入解析Cursor: AI辅助编程的核心技术揭秘

HDFS 频繁进入安全模式的原因及解决方案

文章导航