C++的智能指针

在使用C++开发过程中，最容易也是最麻烦的问题便是内存泄漏。相较于Java、python或者go语言都拥有垃圾回收机制，在对象没有引用时就会被系统自动回收而且基本上没有指针的概念，但是C++则要求程序员自己管理内存，这一方面让程序员有更大的自由度但是也会很大影响程序员的开发效率。因此C++11标准中新推出了shared_ptr、unique_ptr和weak_ptr三个智能指针来帮助管理内存。

shared_ptr共享的智能指针

shared_ptr的使用

shared_ptr使用引用计数，每个shared_ptr的拷贝都指向相同的内存，在最后一个shared_ptr析构的时候内存才会被释放。shared_ptr可以通过构造函数、std::make_shared辅助函数和reset方法初始化。

1
2
3
4
5


std::shared_ptr<int> p(new int(1));
std::shared_ptr<int> p2 = p;

std::shared_ptr<int> ptr;
ptr.reset(new int(1));

不能将一个原始指针直接赋值给一个智能指针，如：std::shared_ptr<int> p = new int(1)。对于一个未初始化的智能指针，可以通过调用reset方法初始化，当智能指针中有值的时候，调用reset方法会使引用计数减一。当需要获取原指针的时候可以通过get方法返回原始指针：

1
2


std::shared_ptr<int> p(new int(1));
int *ptr = p.get();

智能指针初始化时也可以指定删除器，当其引用计数为0时将自动调用删除器来释放对象，删除器可以是一个函数对象。如当使用shared_ptr管理动态数组时，需要指定删除器，因为shared_ptr默认删除器不支持数组对象：

1

std::shared_ptr<int> p(new int[10], [](int *p){delete []p;})//lambda表达式作为删除器

在使用shared_ptr时需要注意的是要避免循环引用，这会导致内存泄漏：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


struct A;
struct B;

struct A {
  std::shared_ptr<B> bptr;
  ~A() {cout<<"A is deleted"<<endl;}
}

struct B {
  std::shared_ptr<A> aptr;
  ~B() {cout<<"B is deleted"<<endl;}
}

int main() {
  {
    std::shared_ptr<A> ap(new A);
    std::shared_ptr<B> bp(new B);
    ap->bptr = bp;
    bp->aptr = ap;
  } //当离开作用域后A，B都应该被析构，但是结果两者都没有被析构，而导致了内存泄漏
}

循环引用导致ap和bp的引用计数都是2，在离开作用域后ap和bp的引用计数减一但并未到达0，导致其不会被析构。

unique_ptr的独占的智能指针

unique_ptr不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique_ptr赋值给另外一个unique_ptr，但是允许通过函数返回给其他的unique_ptr或者通过std::move来转移到其他的unique_ptr，这样的话它本身就不再拥有原指针的所有权了。与shared_ptr相比unique_ptr除了独占性的特点外，还能够指向一个数组：std::unique_ptr<int []> p(new int[10]);。

shared_ptr与unique_ptr的使用需要根据场景决定，如果希望只有一个智能指针管理资源或者管理数组就使用unique_ptr，如果希望使用多个智能指针管理同一个资源就使用shared_ptr。

weak_ptr弱引用的智能指针

弱引用指针weak_ptr是用来监视shared_ptr的，不会使引用计数加1，也不管理shared_ptr的内部指针，主要是为了监视shared_ptr的生命周期。weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，主要是为了通过shared_ptr获得资源的监测权，它的构造不会增加引用计数，析构也不会减少引用计数。此外weak_ptr还可以用来返回this指针和解决循环引用的问题。

weak_ptr可以通过use_count()方法来获得当前观测资源的引用计数：

1
2
3
4


shared_ptr<int> sp(new int(1));
weak_ptr<int> wp(sp);

cout<<wp.use_count()<<endl;

也可以通过expired()方法来判断所观测的资源是否已经被释放：

1
2
3
4
5


if (wp.expired()) {
  cout<<"weak_ptr 无效， 所监视的智能指针已经被释放"<<endl;
} else {
  cout<<"weak_ptr 有效"<<endl;
}

此外还能够通过lock()方法来获取所监视的shared_ptr：

1
2
3
4
5
6
7


if (wp.expired()) {
  cout<<"weak_ptr 无效， 所监视的智能指针已经被释放"<<endl;
} else {
  cout<<"weak_ptr 有效"<<endl;
  auto spt = wp.lock();
  cout<<*spt<<endl; //通过lock方法返回的指针来访问元素
}

之前的shared_ptr在使用的时候不应该将this指针作为返回值，因为this指针本质上是一个裸指针，很容易导致重复析构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


struct A {
  shared_ptr<A> getSelf() {
    return shared_ptr<A> (this);
  }
}

int main() {
  shared_ptr<A> sp1(new A);
  shared_ptr<A> sp2 = sp1->getSelf();

  return 0;
}

以上代码中，由于同一个指针（this）构造了两个智能指针sp1和sp2，而它们之间没有任何关系，在离开作用域之后this指针会被两个智能指针各自析构，导致析构错误。正确的做法是直接通过继承std::enable_shared_from_this<T>然后调用成员函数shared_from_this()返回this指针。因为在enable_shared_from_this<T>类中有一个weak_ptr，通过其观测this智能指针，在调用shared_from_this()方法时，会调用内部这个weak_ptr的lock()方法，将所观测的shared_ptr返回。

除了解决返回this指针的问题，weak_ptr也能用来处理循环引用的问题，只需要将其中任意一个成员变量定义为weak_ptr即可：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


struct A;
struct B;

struct A {
  std::shared_ptr<B> bptr;
  ~A() {cout<<"A is deleted"<<endl;}
}

struct B {
  std::weak_ptr<A> aptr; //改为weak_ptr
  ~B() {cout<<"B is deleted"<<endl;}
}

int main() {
  {
    std::shared_ptr<A> ap(new A);
    std::shared_ptr<B> bp(new B);
    ap->bptr = bp;
    bp->aptr = ap;
  } //当离开作用域后A，B都被析构
}

修改后在对B测成员赋值时bp->aptr = ap;，由于aptr是weak_ptr不会增加引用计数，所以aptr的引用计数仍然是1。

实现简易的shared_ptr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


#include <iostream>
#include <memory>

template<typename T>
class smartPtr {
public:
  smartPtr(T *ptr = nullptr):_ptr(ptr) {
    if (_ptr) {
      _count = new size_t(1);
    } else {
      _count = new size_t(0);
    }
  }

  smartPtr(const smartPtr &ptr) {
    if (this != &ptr) {
      this->_ptr = ptr._ptr;
      this->_count = ptr._count;
      ++(*this->_count);
    }
  }

  smartPtr& operator=(const samrtPtr &ptr) {
    if (this->_ptr == ptr._ptr) return *this;

    if (this->_ptr) {
      --(*this->_count);
      if (this->_count == 0) {
        delete this->_ptr;
        delete this->_count;
      }
    }

    this->_ptr = ptr._ptr;
    this->_count = ptr._count;
    ++(*this->_count);

    return *this;
  }

  ~samrtPtr() {
    --(*this->_count);
    if (0 == *this->_count) {
      delete this->_ptr;
      delete this->_count;
    }
  }

  size_t use_count() {
    return *this->_count;
  }

  T& operator*() {
    assert(this->_ptr == nullptr);
    return *(this->_ptr);
  }

  T* operator->() {
    assert(this->_ptr == nullptr);
    return this->_ptr;
  }
}

通过以上代码简单模拟智能指针的行为，通过观察可以看到：

shared_ptr的尺寸是裸指针的两倍：因为内部既包含一个指向该资源的裸指针，也包含一个指向该资源的引用计数的裸指针。
引用计数的内存必须动态分配
引用计数的递增和递减必须是原子操作：原子操作一般比非原子操作慢。我们的实现版本里为了简单起见没有实现原子操作。

Contents

shared_ptr共享的智能指针

shared_ptr的使用

unique_ptr的独占的智能指针

weak_ptr弱引用的智能指针

实现简易的shared_ptr