【C++】智能指针（上）-阿里云开发者社区

👉内存泄漏👈

什么是内存泄漏、内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。注：内存泄漏是指针丢了，并不是内存丢了，指针丢了就无法释放申请的内存了。

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

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;
  return 0;
}

内存泄漏的分类

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

堆内存泄漏(Heap leak)

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

系统资源泄漏

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

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

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

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

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

注：检测工具的原理：申请的内存用一个容器记录下来，释放内存时，从容器中删除掉。程序结束前或者没有任务跑时，容器中的资源可能就是内存泄漏。

如何避免内存泄漏

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。这个是理想状态，但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。

采用RAII思想或者智能指针来管理资源。

有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结：

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

👉智能指针的使用及原理👈

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

不需要显式地释放资源。

采用这种方式，对象所需的资源在其生命期内始终保持有效

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr 
{
public:
  SmartPtr(T* ptr = nullptr)
    : _ptr(ptr)
  {}
  ~SmartPtr()
  {
    if (_ptr)
    {
      cout << "delete:" << _ptr << endl;
      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()
{
  // 不管Func正常结束还是抛异常，sp1和sp2都会调用析构函数释放资源
  SmartPtr<int> sp1(new int);
  SmartPtr<int> sp2(new int);
  cout << div() << endl;
}
int main()
{
  try
  {
    Func();
  }
  catch (exception& e)
  {
    cout << e.what() << endl;
  }
  return 0;
}

智能指针的原理

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

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr 
{
public:
  SmartPtr(T* ptr = nullptr)
    : _ptr(ptr)
  {}
  ~SmartPtr()
  {
    if (_ptr)
    {
      cout << "delete:" << _ptr << endl;
      delete _ptr;
    }
  }
  T& operator*()
  {
    return *_ptr;
  }
  T* operator->()
  {
    return _ptr;
  }
private:
  T* _ptr;
};

智能指针的原理总结：利用 RAII 思想设计释放资源的类，该类重载了*和->，其具有像指针一样的行为。

std::auto_ptr

C++98版本的库中就提供了 auto_ptr 的智能指针，其在 memory 头文件中。以下是 auto_ptr 的演示使用。

class A
{
public:
  ~A()
  {
    cout << "~A()" << endl;
  }
//private:
  int _a1 = 0;
  int _a2 = 0;
};
int main()
{
  auto_ptr<A> ap1(new A);
  ++ap1->_a1;
  ++ap1->_a2;
  SmartPtr<A> sp1(new A);
  ++sp1->_a1;
  ++sp1->_a2;
  return 0;
}

智能指针看起来完美无瑕，那真的是这样吗？其实智能指针最怕的就是拷贝了，因为拷贝的话可能会存在对一个指针delete两次的问题。

我们自己写的 SmartPtr 没有写拷贝构造函数，编译器会默认生成拷贝构造函数。默认生成的拷贝构造函数对内置类型完成值拷贝，对应自定义类型则调用该类型的拷贝构造。这样就会导致一个问题：sp1 和 sp2 指向同一块空间，程序结束会对同一块空间析构两次，从而导致程序崩溃。

那怎么解决呢？那是不是深拷贝呢？其实深拷贝并不能解决这个问题，因为智能指针是保管指针的。深拷贝违背了功能需求，智能指针需要的就是浅拷贝。那 auto_ptr 是如何解决拷贝构造的问题呢？

通过上图可以看到：auto_ptr 通过管理权转移的方式来解决拷贝问题的。也就是说 ap2 拷贝了 ap1，那么 ap1 会将指针的管理权交给 ap2，ap 变成空指针。这是一种非常挫的解决方法，这样会导致被拷贝对象悬空，是非常危险的做法，只要解引用就会报错。所以，很多公司都明确地要求不能使用 auto_ptr。

auto_ptr 是 C++98 就已经有了的，而新的智能指针到了 C++11 才更新。那么在 C++11 出来之前，大家都是在使用 boost 中设计的scoped_ptr / shared_ptr / weak_ptr，C++11 将 boost 库中智能指针精华部分吸收了过来，设计出了C++11 的unique_ptr / shared_ptr / weak_ptr。

auto_ptr 的模拟实现

namespace Joy
{
  template<class T>
  class auto_ptr
  {
  public:
    auto_ptr(T* ptr = nullptr)
      : _ptr(ptr)
    {}
    // auto_ptr的拷贝构造和赋值运算符重载
    // 的实现原理都是管理权转移
    auto_ptr(auto_ptr<T>& ap)
      :_ptr(ap._ptr)
    {
      ap._ptr = nullptr;
    }
    // ap1 = ap2;
    auto_ptr<T>& operator=(auto_ptr<T>& ap)
    {
      if (this != &ap)
      {
        // 先释放原来的资源
        if (_ptr)
        {
          cout << "Delete:" << _ptr << endl;
          delete _ptr;
        }
        // 再指向新资源并将ap._ptr置为nullptr
        _ptr = ap._ptr;
        ap._ptr = nullptr;
      }
      return *this;
    }
    ~auto_ptr()
    {
      if (_ptr)
      {
        cout << "Delete:" << _ptr << endl;
        delete _ptr;
      }
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
  };
}

std::unique_ptr

unique_ptr 的实现原理：简单粗暴的防拷贝。

unique_ptr 的模拟实现

namespace Joy
{
  template<class T>
  class unique_ptr
  {
  public:
    unique_ptr(T* ptr = nullptr)
      : _ptr(ptr)
    {}
    // C++98的防拷贝做法：将拷贝构造和赋值运算符重载弄成私有,只声明不实现
    // 设置成私有的原因是防止别人在类外实现
    // C++11的防拷贝做法：delete
    unique_ptr(unique_ptr<T>& up) = delete;
    unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;
    ~unique_ptr()
    {
      if (_ptr)
      {
        cout << "Delete:" << _ptr << endl;
        delete _ptr;
      }
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
  };
}

unique_ptr 非常简单粗暴，就是不让你拷贝。但是 unique_ptr 还是没有从根本上解决问题，其只适用于一些不需要拷贝的场景。

【C++】智能指针（上）