【C++高阶】深入理解C++智能指针：掌握RAII与内存安全的利器

📝个人主页🌹：Eternity._
⏩收录专栏⏪：C++ “ 登神长阶 ”
🤡往期回顾🤡：C++异常处理机制
🌹🌹期待您的关注 🌹🌹

❀C++智能指针

前言：在C++的浩瀚宇宙中，内存管理一直是程序员们必须面对的重要课题。从早期的手动分配与释放，到现代C++标准库中引入的智能指针，每一次进步都标志着C++在提升开发效率、减少错误风险方面的巨大飞跃。智能指针，作为C++11及后续版本中不可或缺的一部分，不仅极大地简化了资源管理，还通过其独特的机制有效防止了内存泄漏和野指针的出现，成为了现代C++编程中不可或缺的工具

本文旨在带领读者深入探索C++智能指针的奥秘，从std::unique_ptr到std::shared_ptr，再到较为特殊的std::weak_ptr，我们将一一剖析这些智能指针的设计理念、使用方法、以及它们背后的原理。通过实例演示和理论解析相结合的方式，帮助读者不仅学会如何正确使用智能指针，更能理解其背后的RAII（Resource Acquisition Is Initialization）资源管理思想，从而在C++编程中更加游刃有余地管理资源

我们将一起踏上探索C++智能指针的奇妙旅程，共同见证它在提升代码质量、保障程序安全方面的巨大力量，让我们携手前行，在C++的编程世界中，共同书写属于自己的辉煌篇章！

📒1. 智能指针的引入

内存方面情景代码示例 (C++)：

intdiv(){int a, b;
    cin >> a >> b;if(b ==0){throwinvalid_argument("除0错误");}return a / b;}voidFunc(){int* p1 =newint;int* p2 =newint;
    cout <<div()<< endl;delete p1;
    cout <<"delete p1"<< p1 << endl;delete p2;
    cout <<"delete p2"<< p2 << endl;}intmain(){try{Func();}catch(exception& e){
        cout << e.what()<< endl;}return0;}

当我们正常输入时：程序正常

当我们程序异常终止时：申请的空间并不会被释放

**这样就会造成

内存泄漏

，因此为了能够限制内存泄漏，就有了

智能指针

**

📚2. 智能指针的使用及原理

智能指针（Smart Pointers）是现代C++编程中非常重要的一种内存管理技术，旨在解决原始指针使用过程中的内存泄漏、野指针等问题。智能指针是模板类，能够像普通指针一样被操作，但它能在适当的时候自动释放所管理的对象，从而保证资源的正确释放

⛰️RAII

RAII是一种在C++（以及C++风格的其他编程语言中）常用的资源管理技术。

**它的基本思想是：

资源的获取在对象的构造时完成，而资源的释放（Release）则在对象的生命周期结束时自动执行，通常是在对象的析构函数中完成

。我们实际上把管理一份资源的责任托管给了一个对象，这种方式有助于管理如动态分配的内存、文件句柄、网络连接、互斥锁等需要显式释放的资源**

RAII的好处

• 自动资源管理： RAII通过对象的生命周期来管理资源，一旦对象被销毁，其所管理的资源也会被自动释放，无需手动调用释放函数
• 异常安全： 由于资源的释放是在对象的析构函数中进行的，而析构函数会在对象生命周期结束时自动调用，即使发生异常也是如此，因此可以保证资源的正确释放，避免了资源泄露
• 简化代码： 使用RAII可以使得资源管理相关的代码更加简洁，减少了因忘记释放资源而导致的错误

使用RAII思想设计的SmartPtr类：

template<classT>classSmartPtr{public:SmartPtr(T* ptr =nullptr):_ptr(ptr){}~SmartPtr(){
        cout <<"delete -> "<< _ptr << endl;delete _ptr;}private:
    T* _ptr;};

🌄智能指针的原理

但是刚刚的

SmartPtr

还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过

->

去访问所指空间中的内容，因此：**AutoPtr模板类中还得需要将

*

、

->

重载下，才可让其像指针一样去使用**

template<class T>
    class SmartPtr
    {
    public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){
            cout <<"delete -> "<< _ptr << endl;
            delete _ptr;}

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

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

    private:
        T* _ptr;};intmain(){
    SmartPtr<int>sp1(new int);*sp1 =10
    cout<<*sp1<<endl;return0;}

智能指针的原理：

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

🌞std::auto_ptr

**C++98版本的库中就提供了

auto_ptr

的智能指针**

std::auto_ptr文档

**

auto_ptr

的实现原理：管理权转移的思想，我们来简单模拟实现一下它，来了解它的原理**

auto_ptr模拟实现 (C++)：

template<classT>classauto_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 =nullptr;}return*this;}~auto_ptr(){if(_ptr){
            cout <<"delete -> "<< _ptr << endl;delete _ptr;
            _ptr =nullptr;}}

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

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

**但是由于

auto_ptr

存在较严重的问题，很多公司明确要求不能使用**

voidTest_auto_ptr(){
    pxt::auto_ptr<int>ap1(new int);
    pxt::auto_ptr<int> ap2 = ap1;// 管理权转移，导致ap1对象悬空/*(*ap1)++;
    (*ap2)++;*/}

🌙std::unique_ptr

**C++11中开始提供更靠谱的

unique_ptr

**

std::unique_ptr文档文档

**

unique_ptr

的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份

unique_ptr

来了解它的原理**

C++11出来之前，
boost搞出了更好用的

scoped_ptr/shared_ptr/weak_ptr

之后C++11借鉴了boost库中智能指针，
C++11搞出

unique_ptr/shared_ptr/weak_ptr

unique_ptr模拟实现 (C++)：

template<classT>classunique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if(_ptr){
            cout <<"delete -> "<< _ptr << endl;delete _ptr;
            _ptr =nullptr;}}

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

    T*operator->(){return _ptr;}// 防拷贝unique_ptr(auto_ptr<T>& sp)=delete;
    unique_ptr<T>&operator=(unique_ptr<T>& up)=delete;private:
    T* _ptr;};

voidTest_unique_ptr(){
    pxt::unique_ptr<int>up1(newint);//pxt::unique_ptr<int> up2(up1);}

⭐std::shared_ptr与std::weak_ptr

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

shared_ptr

**

std::shared_ptr文档文档

**

shared_ptr

的原理：是通过引用计数的方式来实现多个

shared_ptr

对象之间共享资源**

• shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享
• 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一
• 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
• 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了

shared_ptr模拟实现 (C++)：

template<classT>classshared_ptr{public:shared_ptr(T* ptr =nullptr):_ptr(ptr),_pcount(newint(1)){}voidrelease(){if(--(*_pcount)==0){//cout << "delete -> " << _ptr << endl;delete _ptr;delete _pcount;}}~shared_ptr(){release();}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){++(*_pcount);}// 获取数量intuse_count()const{return*_pcount;}// 获取指针
    T*get()const{return _ptr;}

    shared_ptr<T>&operator=(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;}private:
    T* _ptr;int* _pcount;};

**强如

shared_ptr

也会存在一定的问题需要我们解决，我们在使用

shared_ptr

的时候一定要注意，不能

循环引用

**

structListNode{int val;
    pxt::shared_ptr<ListNode> prev;
    pxt::shared_ptr<ListNode> next;~ListNode(){
        cout <<"~ListNode()"<< endl;}};voidTest_shared_ptr(){
    pxt::shared_ptr<ListNode>n1(new ListNode);
    pxt::shared_ptr<ListNode>n2(new ListNode);
    cout << n1.use_count()<< endl;
    cout << n2.use_count()<< endl;// 循环引用
    n1->next = n2;
    n2->prev = n1;}

解决方案：
**在引用计数的场景下，把节点中的

_prev和_next改成weak_ptr

就可以了**

**原理就是，node1->_next = node2;和node2->_prev = node1;时

weak_ptr

的_next和_prev不会增加node1和node2的引用计数**

weak_ptr模拟实现 (C++)：

template<classT>classweak_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;};

循环引用解决方案：

structListNode{int val;
    pxt::weak_ptr<ListNode> prev;
    pxt::weak_ptr<ListNode> next;~ListNode(){
        cout <<"~ListNode()"<< endl;}};

删除器

**

shared_ptr

设计了一个删除器来解决一些不是new出来的对象的智能指针管理**

仿函数的删除器 (C++)：

template<classT>structDelArray{voidoperator()(T* ptr){delete[] ptr;}};

**在增加删除器后，

shared_ptr

的参数变多了，因此我们还要修改一下

shared_ptr

的模拟实现**

template<classT>classshared_ptr{public:shared_ptr(T* ptr =nullptr):_ptr(ptr),_pcount(newint(1)){}template<classD>shared_ptr(T* ptr ,D del):_ptr(ptr),_pcount(newint(1)),_del(del){}//function<void(T*)> _del;voidrelease(){if(--(*_pcount)==0){//cout << "delete -> " << _ptr << endl;//delete _ptr;_del(_ptr);delete _pcount;}}// 其他函数.......private:
    T* _ptr;int* _pcount;// 提供一个包装器来确定_del的类型
    function<void(T*)> _del =[](T* ptr){delete[] ptr;};// 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用};

voidTest_shared_ptr2(){// 定制删除器
    pxt::shared_ptr<ListNode>sp1(new ListNode[10],DelArray<ListNode>());// 也可以通过我们之前学习的Lambda来实现
    pxt::shared_ptr<ListNode>sp2(new ListNode[10],[](ListNode* ptr){delete[] ptr;});
    pxt::shared_ptr<ListNode>sp3(new ListNode[10]);

📜3. 内存泄漏

**内存泄漏：指

因为疏忽或错误造成程序未能释放已经不再使用的内存的情况

。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费**

🍁内存泄漏的危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

内存泄漏的原因：

voidFunction(){// 1.内存申请了忘记释放int* p1 =(int*)malloc(sizeof(int));int* p2 =newint;// 2.异常安全问题int* p3 =newint[10];Func();// 如果Func函数抛异常，就会导致 delete[] p3未执行，p3没被释放.delete[] p3;}

🍂内存泄漏的分类与检测 (了解)

C/C++程序中一般有两种方面的内存泄漏：

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

检测内存泄漏：
在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

🌸如何避免内存泄漏

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

内存泄漏常见解决方案分为两种：

• 事前预防型。如智能指针等
• 事后查错型。如泄漏检测工具

📝4. 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

**在C++ 11中，需要注意的是

unique_ptr对应boost的scoped_ptr

。并且这些智能指针的实现原理是参考boost中的实现的**

📖5. 总结

随着我们对C++智能指针的深入探索，不难发现，这一特性不仅是C++标准库中的一颗璀璨明珠，更是现代C++编程中不可或缺的基石。通过智能指针，我们不仅能够享受到自动内存管理的便利，减少手动管理资源所带来的繁琐和错误风险，还能深刻理解RAII（Resource Acquisition Is Initialization）资源管理模式的精髓，从而在编程实践中更加高效、安全地管理资源

我们共同见证了std::unique_ptr、std::shared_ptr以及std::weak_ptr等智能指针的神奇之处，从它们的设计理念到实际应用，从基本用法到高级技巧，我们一步步深入，逐渐揭开了智能指针的神秘面纱。相信通过本文的学习，你已经对C++智能指针有了更为全面和深入的理解，也能够在自己的编程实践中灵活运用这一强大工具

但是我还是想说，学习之路永无止境。智能指针只是C++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌

希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！
谢谢大家支持本篇到这里就结束了，祝大家天天开心！