c++ std::shared_ptr学习_std的share-CSDN博客

背景

c++中智能指针shared_ptr用于自动管理资源，通过引用计数来记录资源被多少出地方使用。在不使用资源时，减少引用计数，如果引用计数为0，表示资源不会再被使用，此时会释放资源。本文记录对c++中std::shared_ptr的源码学习。

为什么需要“智能”指针

当我们需要在堆上分配对象时，可以通过new来创建，在不需要使用对象时，需要使用delete来释放对象占用的资源，如下所示：

void foo() {
    ...
    int *pi = new int(0);
    ...
    delete pi;
    ...
}

如果在delete之前，函数提前return，则new出来的内存不会被释放，导致内存泄露。另外，如果一个对象在函数中被new出来，并作为返回值返回，但是使用者如果不清楚函数内部实现，也可能忘记delete调new出来的对象，导致内存泄露，如下所示：

int* foo() {
    return new int(0);
}


void bar() {
    int *pi = foo();
    ...
    return; // 因为不知道foo返回的int*是new出来的，所以没有delete pi
}

对上面这种场景，还可能会出现一个指针被多处使用。为了确保指针在使用过程中没有被delete，还需要关注指针使用的先后顺序。但在迭代的过程中，这会导致指针的使用变得很难维护。为此，我们需要有一个“智能”的指针，维护我们new出来的对象，并在不需要的时候自动delete，释放资源。

智能指针如何“智能”

c++智能指针利用class的构造函数和析构函数来对指针管理，构造函数中将new出来的指针传入，在析构函数中判断如果没人再使用，则会释放指针。

如何判断指针还被使用呢？答案是使用引用计数。只要指针被引用了，引用计数加1，当某一个引用不再使用（析构之后），则引用计数减1，如果指针不再被使用时，引用计数为0，此时即可delete指针，释放资源。

那如何知道一个指针被引用了呢？答案就是复制构造和赋值构造。如果不知道什么是复制构造和赋值构造，可以先去学习下，以下是个简单的例子：

class A {
public:
    // 构造函数
    A() {
        x = 0;
    }
    // 析构函数
    ~A() {
    }
    // 复制构造
    A(const A &a) {
        x = a.x;
    }
    // 赋值构造
    A& operate=(cosnt A &a) {
        x = a.x;
        return *this;
    }
private:
    int x;
}

int main() {
    A a1; // 构造函数
    A a2(a1); // 复制构造
    A a3 = a1; // 赋值构造
}
// 离开作用域，a1, a2, a3析构

shared_ptr概览

shared_ptr定义如下：

  /**
   *  @brief  A smart pointer with reference-counted copy semantics.
   *
   *  The object pointed to is deleted when the last shared_ptr pointing to
   *  it is destroyed or reset.
  */
  template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
      ...
    }

即shared_ptr继承__shared_ptr，__shared_ptr定义如下：

  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    : public __shared_ptr_access<_Tp, _Lp>
    {
    public:
      using element_type = typename remove_extent<_Tp>::type;
      ...
    private:
      element_type*	   _M_ptr;         // Contained pointer.
      __shared_count<_Lp>  _M_refcount;    // Reference counter.
    }

从注释中可以看出，__shared_ptr中有两个成员变量：_M_ptr和_M_refcount。_M_ptr是智能指针管理的资源，_M_refcount是引用计数。再看下_M_refcount的类型定义，即__shared_count：

  template<_Lock_policy _Lp>
    class __shared_count
    {
    ...
    private:
      _Sp_counted_base<_Lp>*  _M_pi;
    };



  template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base
    : public _Mutex_base<_Lp>
    {
    ...
    private:
      _Atomic_word  _M_use_count;     // #shared
      ...
    };



typedef int _Atomic_word;

可以看出，引用计数本质是一个int值：_M_use_count。

shared_ptr简单的类图示意如下：

根据智能指针实现方式，我们主要考虑构造函数、析构函数、复制构造函数、赋值构造函数。

构造函数

用以下代码作为示例说明智能指针构造过程：

class A {
public:
    A() {
        cout << "construct A" << endl;
    }

    ~A() {
        cout << "deconstruct A" << endl;
    }
};

void test_init() {
    shared_ptr<A> pa(new A);
}

当test函数被调用是，创建了一个A指针，该指针作为shared_ptr入参传入构造函数，shared_ptr构造函数调用过程如下：


      // shared_ptr构造函数

      /**
       *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
       *  @param  __p  A pointer that is convertible to element_type*.
       *  @post   use_count() == 1 && get() == __p
       *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
       */
      template<typename _Yp, typename