【C++】智能指针（RAII）详解

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++11unique_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对象之间共享资源。

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

  循环引用是指两个或多个对象之间相互引用，形成一个闭环的情况。这种情况下，由于每个对象都持有其他对象的引用计数，导致共享指针无法正确地释放内存。下面我们来看一个实际的例子：

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::weak_ptr _next;std::weak_ptr _prev;~Node(){cout << "~Node" << endl;}};

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

4、1 什么是内存泄漏

  内存泄漏是指在计算机程序中，通过动态分配内存空间后，无法再次释放这些空间的情况。当程序运行时，如果不再使用某段动态分配的内存空间，但没有显式地将其释放，就会导致内存泄漏的问题。

  内存泄漏可能会导致系统性能下降甚至崩溃。随着时间的推移，内存泄漏会使可用内存越来越少，最终导致程序运行失败或系统崩溃。

  在C++中，内存泄漏通常出现在以下情况下：

1. 动态分配内存后未释放：当使用关键字new或者相关的内存分配函数（例如malloc）在堆上分配了内存空间后，如果没有调用对应的释放函数（例如delete或者free），就会发生内存泄漏。这种情况经常出现在忘记释放内存、程序异常退出等情况下。
2. 在循环中动态分配内存未释放：当在循环中重复动态分配内存空间而未及时释放，在每次循环迭代时都会导致一次内存泄漏。

   for (int i = 0; i < 10; i++) {    int* ptr = new int; // 动态分配了一个int型的内存空间    // 未在每次循环结束时释放ptr指向的内存空间，导致每次循环都有内存泄漏}

3. 没有正确管理对象的生命周期：当对象在不再使用时没有及时销毁或释放资源，也可能导致内存泄漏。

   class MyClass {public:    MyClass() {        buffer = new int[1000]; // 在构造函数中动态分配了一个int数组    }    ~MyClass() {        // 在析构函数中应该释放buffer指向的内存空间，但这里没有进行释放    }private:    int* buffer;};void foo() {    MyClass obj;    // 在此处，obj的析构函数没有被调用，导致buffer指向的内存泄漏}

4. 循环引用：如果两个或多个对象互相引用，并且没有其他对象引用它们，那么这些对象将无法很好的释放资源，导致内存泄漏。

5. 异常跳转，可能会直接跳转过了释放资源的语句。也会导致内存泄漏。

4、2 内存泄漏分类

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

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

4、3 如何规避内存泄漏

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

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