【C++】智能指针（RAII）详解
我们在上篇文章中（异常处理详解）提到了 RAII 。那么本篇文章会对此进行详解。重点是智能指针的详解。其中会讲解到 RAII 思想、auto_ptr、unique_ptr、shared_ptr、weak_ptr、循环引用问题。希望本篇文章会对你有所帮助。
文章目录
一、为什么需要智能指针
二、智能指针的使用及原理
2、1 RAII 解释
2、2 什么是智能指针
2、3 auto_ptr
2、3、1 auto_ptr 的使用
2、3、2 auto_ptr 的模拟实现
2、4 unique_ptr
三、循环引用问题及解决
3、1 weak_ptr
四、内存泄漏问题
4、1 什么是内存泄漏
4、2 内存泄漏分类
4、3 如何规避内存泄漏
♂️ 作者：@Ggggggtm ♂️
专栏：C++
标题：智能指针
❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️
一、为什么需要智能指针
我们先看如下一段代码：
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; }上述一段简短的代码，其实隐含了许多问题。这里给出三个问题：1、如果p1这里new 抛异常会如何？2、如果p2这里new 抛异常会如何？3、如果div调用这里又会抛异常会如何？其实都会造成内存泄露。当然，我们上篇文章也讲到，可以选择异常重新抛出进行解决，但是如果 p2 内存申请失败了呢？有人说可以进行异常检查。确实可以处理。但是这仅仅只有两个动态申请指针。如果类似还有p3、p4、p5……就要进行很复杂的分情况处理。
智能指针就可以很轻松的解决上述的情况。下面我们学习一下智能指针。
二、智能指针的使用及原理
2、1 RAII 解释
在了解指针指针之前，我们先学习一下RAII。
RAII，全称Resource Acquisition Is Initialization（资源获取即初始化），是一种在C++中用于管理资源的编程技术。它基于一种简单的原则，即在对象的构造函数中获得资源（例如内存、文件句柄、锁等），并在析构函数中释放这些资源。RAII采用的是C++的对象生命周期管理机制，确保在对象离开作用域时资源的正确释放，无论是通过正常流程离开还是通过异常离开。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效。
我们通过一段代码来理解一下：
// 使用RAII思想设计的SmartPtr类 templateclass 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() { ShardPtr sp1(new int); ShardPtr sp2(new int); cout << div() << endl; } int main() { try { Func(); } catch (const exception& e) { cout << e.what() << endl; } return 0; } 上述代码就是把动态申请的资源交给一个类对象处理，我们只需要在该类的析构函数中对该对象进行释放即可。这样做的好处是什么呢？首先，我们不用自己手动去释放动态申请的资源。其次，即使程序出现异常崩溃了，也会将资源释放掉（类对象出了作用域会自动调用析构函数）。上述思想就是所谓了资源获取即初始化。
2、2 什么是智能指针
传统的指针在使用过程中需要手动分配和释放内存，经常容易出现内存泄漏或者悬挂指针等问题，给程序带来安全隐患。
智能指针是一种特殊类型的指针，它可以自动管理内存的分配和释放，为程序员提供方便和安全。智能指针通过在对象生命周期结束时自动释放指向的内存空间，减少了内存泄漏的风险。
我们发现智能指针的概念就是采用了RAII的思想。与上面 SmartPtr 极为相似。但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容。代码如下：templateclass 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 sp1(new int); *sp1 = 10; cout << *sp1 << endl; // 需要注意的是这里应该是sparray.operator->()->_year = 2018; // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个-> SmartPtr sparray(new Date); sparray->_year = 2018; sparray->_month = 1; sparray->_day = 1; return 0; }
2、3 auto_ptr
在C++中,auto_ptr是一个早期的智能指针类，用于管理动态分配的对象。它是C++98标准引入的，但已在C++11中基本上被废弃。我们来看看其使用和为什么要别弃用。
2、3、1 auto_ptr 的使用
我们先看如下代码：
class A { public: ~A() { cout << "~A()" << endl; } //private: int _a1 = 0; int _a2 = 0; }; int main() { auto_ptr ap1(new A); ap1->_a1++; ap1->_a2++; auto_ptr ap2(ap1); ap1->_a1++; ap1->_a2++; return 0; }运行结果是崩溃了，如下图：
这是为什么呢？当将一个auto_ptr拷贝给另一个auto_ptr时，将会管理权（资源）转移（这里是指将ap1的资源转移给了ap2）。
这个看上去好像没有什么问题，但是又好像是一个bug级别的存在。因为一不下心再去使用ap1 时，就会出现内存问题。其实底层实现也是管理权转移的思想。这也是auto_ptr现在基本上被弃用的原因了。auto_ptr 的接口含有很多，这里就不再一一解释。
我们再看一下其底层实现。
2、3、2 auto_ptr 的模拟实现
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理。
templateclass auto_ptr { public: auto_ptr(T* ptr = nullptr) : _ptr(ptr) {} auto_ptr(auto_ptr & ap) :_ptr(ap._ptr) { ap._ptr = nullptr; } // ap1 = ap2; auto_ptr & operator=(auto_ptr & ap) { if (this != &ap) { if (_ptr) { delete _ptr; } _ptr = ap._ptr; ap._ptr = nullptr; } return *this; } ~auto_ptr() { if (_ptr) { delete _ptr; } } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; }; 注意，赋值并不只是资源转移。赋值是先将原本对象的资源进行释放，在进行资源转移。同时，在模拟实现时也需要注意是否自己和自己进行赋值。
2、4 unique_ptr
unique_ptr 针对auto_ptr 的不足进行了调整，但是调整的有点暴力。在unique_ptr 中，直接将拷贝构造和拷贝赋值直接禁用了。
其用法与auto_ptr 基本相似，只不过是尽禁掉了拷贝构造和拷贝赋值。我们再来看一下其底层的简单模拟实现。代码如下：
templateclass unique_ptr { private: // 防拷贝 C++98 // 只声明不实现 //unique_ptr(unique_ptr & ap); //unique_ptr & operator=(unique_ptr & ap); public: unique_ptr(T* ptr = nullptr) : _ptr(ptr) {} // 防拷贝 C++11 unique_ptr(unique_ptr & ap) = delete; unique_ptr & operator=(unique_ptr & ap) = delete; ~unique_ptr() { if (_ptr) { cout << "Delete:" << _ptr << endl; delete _ptr; } } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; }; unique_ptr与auto_ptr极为相似，就不再过多解释unique_ptr。我们重点是在shared_ptr。
2、5 shared_ptr
shared_ptr 针对之前的智能指针的问题进行了修改调整。不仅仅支持拷贝，而且也更加安全。其使用我们也不再过多详解，主要看一下其底层实现。
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数（引用计数），用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
那我们怎么来维护这个计数呢？首先，普通的 int 成员是不可以的。因为我们想要的时一个类对象只有一个计数。如果是普通的 int 成员，实例化每个对象都会都一个计数。
用static 成员可不可以呢？也是不行的！我们看如下代码：
shared_ptr sp1(new A); shared_ptr sp2(sp1); shared_ptr sp3(sp1); shared_ptrsp4(new int); 如果是 static 成员，那么不同类型的对象也是共享一个计数。显然这样是不正确的。
采用一个指针可不可以呢？答案是可以的。我们采用指针时，只有在构造时，才进行申请新的指针。当采用拷贝或者赋值时，我们选择将指针进行资源转移，而不是申请新指针。这样就可以很好的控制一个类对象只有一个计数了。下面我们结合模拟实现的代码理解一下：
templateclass 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(); } // sp1(sp2) shared_ptr(const shared_ptr & sp) : _ptr(sp._ptr) , _pCount(sp._pCount) { (*_pCount)++; } // sp1 = sp5 // sp1 = sp1 // 20:16继续 shared_ptr & operator=(const shared_ptr & sp) { //if (this == &sp) if (_ptr == sp._ptr) { return *this; } // 减减被赋值对象的计数，如果是最后一个对象，要释放资源 /*if (--(*_pCount) == 0) { delete _ptr; delete _pCount; }*/ Release(); // 共管新资源，++计数 _ptr = sp._ptr; _pCount = sp._pCount; (*_pCount)++; return *this; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; // 引用计数 int* _pCount; }; }
三、循环引用问题及解决
循环引用是指两个或多个对象之间相互引用，形成一个闭环的情况。这种情况下，由于每个对象都持有其他对象的引用计数，导致共享指针无法正确地释放内存。下面我们来看一个实际的例子：
struct Node { int _val; std::shared_ptr_next; std::shared_ptr _prev; ~Node() { cout << "~Node" << endl; } }; void test_shared_ptr2() { std::shared_ptr n1(new Node); std::shared_ptr n2(new Node); n1->_next = n2; n2->_prev = n1; } 我们可以简单的理解为：双向链表中存储的是智能指针。这时候就引发了循环引用的问题。具体如下图：
这个时候可以采用weak_ptr 来进行解决。
3、1 weak_ptr
weak_ptr是与shared_ptr配套使用的弱引用指针。它可以解决循环引用问题，因为它不会增加内存的引用计数。我们先看一下代码：
struct Node { int _val; /*std::shared_ptr_next; std::shared_ptr _prev;*/ std::weak_ptr _next; std::weak_ptr _prev; ~Node() { cout << "~Node" << endl; } }; _next和_prev是weak_ptr时，他不参与资源释放管理，可以访问和修改到资源，但是不增加计数，不存在循环引用的问题了。
四、内存泄漏问题
4、1 什么是内存泄漏
内存泄漏是指在计算机程序中，通过动态分配内存空间后，无法再次释放这些空间的情况。当程序运行时，如果不再使用某段动态分配的内存空间，但没有显式地将其释放，就会导致内存泄漏的问题。
内存泄漏可能会导致系统性能下降甚至崩溃。随着时间的推移，内存泄漏会使可用内存越来越少，最终导致程序运行失败或系统崩溃。
在C++中，内存泄漏通常出现在以下情况下：
- 动态分配内存后未释放：当使用关键字
new或者相关的内存分配函数（例如malloc）在堆上分配了内存空间后，如果没有调用对应的释放函数（例如delete或者free），就会发生内存泄漏。这种情况经常出现在忘记释放内存、程序异常退出等情况下。- 在循环中动态分配内存未释放：当在循环中重复动态分配内存空间而未及时释放，在每次循环迭代时都会导致一次内存泄漏。
for (int i = 0; i < 10; i++) { int* ptr = new int; // 动态分配了一个int型的内存空间 // 未在每次循环结束时释放ptr指向的内存空间，导致每次循环都有内存泄漏 }- 没有正确管理对象的生命周期：当对象在不再使用时没有及时销毁或释放资源，也可能导致内存泄漏。
class MyClass { public: MyClass() { buffer = new int[1000]; // 在构造函数中动态分配了一个int数组 } ~MyClass() { // 在析构函数中应该释放buffer指向的内存空间，但这里没有进行释放 } private: int* buffer; }; void foo() { MyClass obj; // 在此处，obj的析构函数没有被调用，导致buffer指向的内存泄漏 }循环引用：如果两个或多个对象互相引用，并且没有其他对象引用它们，那么这些对象将无法很好的释放资源，导致内存泄漏。
异常跳转，可能会直接跳转过了释放资源的语句。也会导致内存泄漏。
4、2 内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏(Heap leak)。堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄漏。指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
4、3 如何规避内存泄漏
- 1工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总的来说，内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。