smart pointer的设计和实现

总体思想是用栈对象封装堆上的资源，利用栈对象必然被回收的性质，达到堆资源自动管理的目的，避免人工delete的error-prone和异常导致的泄露。

1 unique_ptr

拷贝构造函数和赋值操作符的实现里，要把源对象的指针置空，因为涉及了修改源对象，不符合拷贝或赋值的只读语义，所以或者干脆不支持拷贝和赋值，只能move。move的时候之前unique_ptr的内部指针置空，这样析构的时候指针为空不delete。

template <typename T>
class unique_ptr {
 friend unique_ptr move(unique_ptr&);
private:
 T* p;
 unique_ptr(unique_ptr& s) {
  p = s.p;
  s.p = nullptr;
 }
 unique_ptr & operator=(unique_ptr& source) {
  p = source.p;
  source.p = nullptr;
  return *this;
 }
public:
 unique_ptr(T* ptr) : p(ptr) {}
 ~unique_ptr() {
  if (p != nullptr) delete p;
 }
};
template <typename T>
unique_ptr<T> move(unique_ptr<T> & s) {
 unique_ptr t = s;
 return t;
}

2 shared_ptr

1）除了资源指针，还行需要引用计数，而且这个计数放在堆上，这样所有的shared_ptr可以共享

2）构造函数创建计数，初始化为1，

3）拷贝构造函数 increment 计数。

4）析构的时候先decrement reference counter，如果 counter == 0 则delete释放资源

template <typename T>
class shared_ptr {
private:
 T* p;
 int* counter;
public:
 shared_ptr(T* ptr) : p(ptr) {
  assert p != nullptr;
  counter = new int;
  *counter = 1;
 }
 shared_ptr(shared_ptr& other) {
  //handle old smart pointer
  *counter -= 1;
  if (*counter == 0) { 
   delete p; 
   delete counter;
  }
  // handle new smart pointer
  counter = other.counter;
  p = other.p;
  *counter += 1;
 }
 ~shared_ptr() {
  *counter -= 1;
  if (*counter == 0) { delete p; delete counter; }
 }
};

3 weak_ptr

和share_ptr的语义一样，也是shared的，区别是weak_ptr不改变引用计数，也不管理内存。主要用于解决循环引用问题，和share_ptr一起。reference count的经典问题就是循环引用问题，两个对象互相引用（通过smart pointer instance 变量），所有栈上的smart pointer都没了，两个对象里的smart pointer还互相引用着。

A通过 shared_ptr引用B，B通过weak_ptr引用A，当A的所有的栈上的shared_ptr都没了，A就会被析构，因为B对A的引用是不算数的，栈上最后一个A的强引用离开作用域的时候，A的reference count就count down到0了，A那时候就会被destroy。A destroy的时候，对B的引用会置空，会处理original smart pointer，count down B的引用，并destroy。

Note：一个 a = b 赋值语句隐含4个操作

RC(b) += 1

RC(a) -= 1

if (RC(a) == 0) //de-allocate the object a points to

a = b

smart pointer的设计和实现

浏览过的版块