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