程序员成长之旅—

程序员成长之旅——智能指针

智能指针的发展旅程
智能指针的模拟实现
智能指针常见的问题个人理解

智能指针的发展旅程

我所了解的智能指针其实是为了解决一些异常安全的问题的，它是运用RAII思想封装的类，从而可以达到自动析构的形式。

auto_ptr
C++98提出来的第一个智能指针，它是一个类似管理权转让的形式，拷贝构造或者赋值的时候，将其原本的管理权转交给新的对象。
unique_ptr
C++11提出来的，它的特性非常的明确，就是防拷贝和赋值，将其私有化，或者delete。
shared_ptr
C++11提出来的，这是为了可以支持拷贝和赋值出现的，它的底层其实是用引用计数来实现的。
weak_ptr
这边这个C++11提出来的主要是为了弥补shared_ptr的缺点，有循环引用的可能，因此是用它来解决的。

智能指针的模拟实现

auto_ptr

template<class T>class auto_ptr {public:auto_ptr(T* ptr = nullptr) :_ptr(ptr){}auto_ptr(const auto_ptr<T>& tmp){_ptr = tmp._ptr;tmp._ptr = nullptr;}auto_ptr<T>& operator=(const auto_ptr<T>& tmp){if (_ptr != tmp._ptr){if(_ptr)delete(_ptr);_ptr = tmp._ptr;tmp._ptr = nullptr;}return *this;}~auto_ptr(){if (_ptr)delete(_ptr);}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};

从上面我们可以看到，运用auto_ptr的话，在将管理权转让出去之后，如果我们在使用原对象，就会出现错误，为了避免这种错误，C++11提出了更优的智能指针。
unique_ptr

template<class T>class unique_ptr{public:unique_ptr(T* ptr = nullptr):_ptr(ptr){}~unique_ptr(){if (_ptr)delete(_ptr);}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//C++11的用法unique_ptr(const unique_ptr<T>&) = delete;unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;private:T* _ptr;};

shared_ptr

     template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr),_pCount(new int(1)),_mtu(new mutex){}shared_ptr(const shared_ptr<T>& tmp):_ptr(tmp._ptr),_pCount(tmp._pCount),_mtu(tmp._mtu){AddRef();}shared_ptr<T>& operator=(const shared_ptr<T>& tmp){if (_ptr != tmp._ptr){Release();_ptr = tmp._ptr;_pCount = tmp._pCount;AddRef();}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~shared_ptr(){Release();}private:void AddRef(){_mtu->lock();++(*_pCount);_mtu->unlock();}void Release(){bool flag = false;_mtu->lock();if (--(*_pCount) == 0){delete(_pCount);delete(_ptr);flag = true;}_mtu->unlock();if (flag == true)delete(_mtu);}T* _ptr;int* _pCount;mutex* _mtu;};

以上就是shared_ptr的简单模拟实现，它所存在的最大问题就是，它会有循环引用的问题。举个例子：

typedef struct ListNode{shared_ptr<ListNode> _next;shared_ptr<ListNode> _prev;int _val;}ListNode;void Test(){shared_ptr<ListNode> t1(new ListNode);shared_ptr<ListNode> t2(new ListNode);t1->_next = t2;t2->_prev = t1;}

画个图就理解为何出现循环引用了

而为了解决这个情况，我们就引入了弱指针，来解决这个问题。
weak_ptr

 template<class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& tmp){_ptr = tmp.GetPtr();}weak_ptr<T>& operator=(const shared_ptr<T>& tmp){_ptr = tmp.GetPtr();return *this;}private:T* _ptr;};struct ListNode{//我们将会发生循环引用的指针用弱指针来完成它weak_ptr<ListNode> _next;weak_ptr<ListNode> _prev;int _val;};void Test(){shared_ptr<ListNode> t1(new ListNode);shared_ptr<ListNode> t2(new ListNode);t1->_next = t2;t2->_prev = t1;}

简单的来说，weak_ptr就是只要能构成循环引用的，我们都不将它进行计数加加，这样的话就能有效解除掉循环引用的问题了。

智能指针常见的问题个人理解

1.模拟实现shared_ptr的时候，引用计数是放在栈上还是堆上，说其中原因？
是在堆上的
我认为不放在栈上的理由很简单，就是为了手控这个释放内存的时刻，不会让编译器自动控制，这样子的话，就可能会造成，多个对象指向同一个控制块，当某一个对象作用域结束的时候，栈上面的这个引用计数就会释放，其它的在使用就会出错。

2.模拟shared_ptr的时候为何在计数++和–的时候要加锁？
会有线程安全的问题
因为++和–是非原子操作的，因此会出现多个线程争抢访问，从而出现线程安全的问题，因此要将其加锁，保证其原子性操作。

补充一个小知识点：+ +为何不是线程安全的
拿++来说的话，它的内部执行至少有三个指令
从内核读取数据
将数据读取到寄存器+1
将寄存器数据写入到内核
并且这三个指令是独立运行的，它们单方面都是原子操作的，但是在多线程并发的情况下，如果两个操作及两个操作以上是一体的话，就是非原子操作，也就是引发线程安全问题的真正缘由。
以上有任何问题，欢迎指正