首页 > 编程语言 >[C++][C++11][智能指针]分析详解 + 代码模拟

[C++][C++11][智能指针]分析详解 + 代码模拟

时间：2024-04-05 20:01:46浏览次数：28  
标签：11 泄漏 int C++ 详解 内存 shared ptr 指针

目录

0.智能指针三要素:)

  • 利用RAII思想设计delete资源的类
  • 像指针一样的行为
  • 拷贝问题 --> 很多解决方案

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

  • 先分析一下这段程序有什么内存方面的问题？
    • 抛异常后，会直接跳转到catch部分，导致原本的delete被跳过，导致内存泄漏
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;
}

2.内存泄漏

1.什么是内存泄漏？内存泄漏的危害?

  • 内存泄漏：
    • 内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况
    • 内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费
  • 内存泄漏的危害：
    • 长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死
void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int *p1 = (int *)malloc(sizeof(int));
    int *p2 = new int;

    // 2.异常安全问题
    int *p3 = new int[10];
    Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
    delete[] p3;
}

2.内存泄漏分类（了解）

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

3.如何检测内存泄漏

4.如何避免内存泄漏

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

3.RAII

  • RAII(Resource Acquisition Is Initialization)(获取到资源马上初始化)是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术
  • 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源
    • 借此，实际上把管理一份资源的责任托管给了一个对象
  • 这种做法有两大好处：
    • 不需要显式地释放资源
    • 采用这种方式，对象所需的资源在其生命期内始终保持有效
// 使用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()
{
    SmartPtr<int> sp1(new int);
    SmartPtr<int> sp2(new int);
    cout << div() << endl;
}

int main()
{
    try
    {
        Func();
    }
    catch (const exception &e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

4.智能指针原理

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

    SmartPtr<Date> sparray(new Date);
    // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    sparray->_year = 2018;
    sparray->_month = 1;
    sparray->_day = 1;
}
  • 总结智能指针原理：
    • RAII特性
    • 重载operator*和opertaor->，具有像指针一样的行为

5.auto_ptr(失败设计)

  • auto_ptr文档
  • 实现原理：资源管理权转移的思想，不负责任的拷贝，会导致拷贝对象悬空
  • 很多公司明确要求不能使用它
// C++98 管理权转移 auto_ptr
template <class T>
class auto_ptr
{
public:
    auto_ptr(T* ptr)
        : _ptr(ptr)
    {}

    auto_ptr(auto_ptr<T>& sp)
        : _ptr(sp._ptr)
    {
        // 管理权转移
        sp._ptr = nullptr;
    }

    auto_ptr<T>& operator=(auto_ptr<T>& ap)
    {
        // 检测是否为自己给自己赋值
        if (this != &ap)
        {
            // 释放当前对象中资源 -- 很重要，否则会内存泄漏
            if (_ptr)
                delete _ptr;

            // 转移ap中资源到当前对象中
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }

        return *this;
    }

    ~auto_ptr()
    {
        if (_ptr)
        {
            cout << "delete:" << _ptr << endl;
            delete _ptr;
        }
    }

    // 像指针一样使用
    T &operator*()
    {
        return *_ptr;
    }

    T *operator->()
    {
        return _ptr;
    }
private:
    T *_ptr;
};

6.unique_ptr

  • unique_ptr文档
  • 实现原理：简单粗暴的防拷贝 – 只适用于不需要拷贝的一些场景
// C++11库才更新智能指针实现
// 原理：简单粗暴 -- 防拷贝
template <class T>
class unique_ptr
{
public:
    unique_ptr(T *ptr)
        : _ptr(ptr)
    {}

    unique_ptr(const unique_ptr<T>& sp) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

    ~unique_ptr()
    {
        if (_ptr)
        {
            cout << "delete:" << _ptr << endl;
            delete _ptr;
        }
    }

    // 像指针一样使用
    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }
private:
    T* _ptr;
};

7.shared_ptr

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

  • shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享
  • 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一
  • 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
  • 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
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();
    }

    shared_ptr(const shared_ptr<T>& sp)
        : _ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        (*_pCount)++;
    }

    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        if (_ptr == sp._ptr)
        {
            return *this;
        }

        // --被赋值对象的计数，如果是最后一个对象，要释放资源
        Release();

        // 共管新资源，++计数
        _ptr = sp._ptr;
        _pCount = sp._pCount;
        (*_pCount)++;

        return *this;
    }

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

    T *operator->()
    {
        return _ptr;
    }
private:
    T *_ptr;
    int *_pCount; // 引用计数
};

// 简化版本的weak_ptr实现
template <class T>
class weak_ptr
{
public:
    weak_ptr()
        : _ptr(nullptr)
    {}

    weak_ptr(const shared_ptr<T> &sp)
        : _ptr(sp._ptr)
    {}

    weak_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        _ptr = sp._ptr;
        return *this;
    }

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

    T* operator->()
    {
        return _ptr;
    }
private:
    T *_ptr;
};

2.shared_ptr的线程安全问题

  • 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的
    • 引用计数原来是1，++了两次，可能还是2，这样引用计数就错乱了，会导致资源未释放或者程序崩溃的问题
    • 所以智能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的
  • 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题

3.shared_ptr的循环引用

  • 循环引用分析：

    • 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成员

    • 所以这就叫循环引用，谁也不会释放

      在这里插入图片描述

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

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

  • 可以将weak_ptr看成shared_ptr的小跟班，它主打辅助

    • weak_ptr不是常规智能指针，没有RAII，不支持直接管理资源
    • weak_ptr主要用shared_ptr构造，用来解决shared_ptr循环引用问题
struct ListNode
{
    int _data;
    weak_ptr<ListNode> _prev;
    weak_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;
}
  • 如果不是new出来的对象如何通过智能指针管理呢？shared_ptr设计了一个删除器来解决这个问题
// 仿函数的删除器
template <class T>
struct FreeFunc
{
    void operator()(T* ptr)
    {
        cout << "free:" << ptr << endl;
        free(ptr);
    }
};

template <class T>
struct DeleteArrayFunc
{
    void operator()(T* ptr)
    {
        cout << "delete[]" << ptr << endl;
        delete[] ptr;
    }
};

int main()
{
    FreeFunc<int> freeFunc;
    std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);

    DeleteArrayFunc<int> deleteArrayFunc;
    std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
    
    std::shared_ptr<A> sp4(new A[10], [](A* p){ delete[] p; });
    std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE *p){ fclose(p); });
    return 0;
}

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

  • C++ 98 中产生了第一个智能指针auto_ptr
  • C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
  • C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版
  • C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的

标签：11,泄漏,int,C++,详解,内存,shared,ptr,指针
From： https://blog.csdn.net/qq_37281656/article/details/137396369

相关文章

  • 蓝桥杯_省_21B_E_路径（c++）
    题目描述小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图中的最短路径。小蓝的图由2021个结点组成，依次编号1至2021。对于两个不同的结点a,b，如果a和b的差的绝对值大于21，则两个结点之间没有边相连；如果a和b的差的绝对值小于等于21，则两个点之间......
  • 数据结构：详解【树和二叉树】
    1.树的概念及结构（了解）1.1树的概念树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。1.2树的结构1.3树与非树：1.4树在实际中的运用（表示文件系统的目录树结构）2.......
  • 类与对象(上)(C++)
    类的引入C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。typedefintDataType;structStack{voidInit(size_......
  • 微软发布整合了2024年3月更新的免费Windows 11虚拟机（WDE）
    下载虚拟机目前，我们将虚拟机打包为四种不同的虚拟化软件选项： VMWare、 Hyper-V(Gen2) 、 VirtualBox 和 Parallels。这些虚拟机包含 Windows的评估版本 ，该版本在发布日期到期。如果评估期过期，桌面背景将变为黑色，你将看到一条永久性桌面通知，指示系统不是正版，并且电脑......
  • C#–特性详解
    一、特性是什么1、特性定义特性（Attribute）是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[]）来描述的。特性（Attribute）用于添加元数......
  • C#-反射详解
    一、反射是什么1、C#编译运行过程高级语言->编译->dll/exe文件->CLR/JIT->机器码2、原理解析metadata：元数据数据清单，记录了dll中包含了哪些东西,是一个描述。IL：中间语言，编译把高级语言编译后得到的C#中最真实的语言状态，面向对象语言。反射：来自于System.Reflection，是一个帮助类......
  • C#泛型详解
    一、什么是泛型泛型是C#2.0推出的新语法，不是语法糖，而是2.0由框架升级提供的功能。我们在编程程序时，经常会遇到功能非常相似的模块，只是它们处理的数据不一样。但我们没有办法，只能分别写多个方法来处理不同的数据类型。这个时候，那么问题来了，有没有一种办法，用同一个方法来处理传入......
  • c++ static_cast显式类型转换
    static_cast<>在C++中是一种用于执行显式类型转换的运算符，它在编译时检查类型转换的有效性，比C风格的强制转换（如(int)x）提供了更强的类型检查。基本类型之间的转换用于基本数据类型（如int、float、double等）之间的转换，使得不同类型的数据可以进行操作。inti=10;float......
  • 【c++小课堂】赋值语句与运算符
    赋值语句 赋值语句的介绍与格式赋值语句，我们在上期已经介绍过了，它就是用来给一个变量or常量一个值的。likethis：intq;q=100;格式：变量or常量=值奇奇怪怪的赋值懒人式赋值1,运算符+'='举个例子：inta;a=5;a+=4;//和a=a+4作用一样可以这样写的运算符有：+，-，*，/，%，>>......
  • 预处理详解
    一.预定义符号在C语言里设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间使用的。__FILE__：进行编译的源文件__LINE__：文件当前行号__DATE__：文件被编译的日期__TIME__：文件被编译的时间__STDC__：如果编译器遵循ANSIC，其值为1，否则未定义我们可以直接使用这些符......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99