智能指针

相信大家都忘写过delete或者free？
如果你没有

诚然，指针的C系语言的优势，但它所带来的的内存泄露问题也是劣势，可谓成也萧何败萧何。

所以，C++引入智能指针，利用类对象出作用域析构的特点，将普通指针封装称为智能指针以达到解决内存泄漏的问题。
下面是一个智能指针的简单例子：

template<typename T>
class Csmartptr
{
public:
	Csmartptr(T* ptr = nullptr) :mptr(ptr) {}
	Csmartptr(const Csmartptr<T> &src)
	{
		mptr = new T(*src .mptr) ;
	}
	~Csmartptr() { delete mptr; }
	T& operator*() { return *mptr; }
	T* operator->{return mptr; }
private:
	T* mptr;
};

其实也就是对指针的一个简单的封装。

浅拷贝问题

但是，这样的智能指针会带来一个浅拷贝问题：

Csmartptr<int> pl (new int) ;
Csmartptr<int> p2 (p1) ;
*p1 = 20;
*p2 = 30;

在上述代码中，对*p1的结果并不是我们想要的30，原因就在于他们各自拥有一块儿堆内存空间。

下面讲给大家介绍三种不带引用计数的智能指针来解决这个问题。
它们都在头文件：#include<memory>中。

auto_ptr

看这个例子：

auto_ptr<int> ptr1 (new int) ;
auto_ptr<int> ptr2 (ptr1) ;
*ptr2 = 20;
cout<<ptr1 << endl;

会运行崩溃！

想知道原因我们就需要来看auto_ptr的底层机制。

autb_ptr (auto_ptr& _Right) noexcept
:_Myptr(_ Right. release() ){}

可以看到，auto_ptr调用了release方法，那么release方法又干了什么呢？

_Ty* rerlease() noexcept
{
	_Ty* _Tmp = _Myptr;
	_Myptr = nullptr;
	return (_Tmp) ;
}

原来是ptr1把自己的资源给ptr2了然后把自己置为空，对空指针解引用当然会报错了。

但是这样的方式无疑很怪异，指针赋值到最后只有最后的指针才指向资源，不带这样薪火相传的吧！
所以auto_ptr不建议使用。

scoped_ptr

scoped_ptr(const scoped_ptr<T> &)= delete;
scoped_ptr<T>& operator=(const scoped_ptr<T> &)=delete;

好家伙，这位直接给浅拷贝的拷贝构造给删了，从源头解决问题。

解决不了问题就解决提出问题的人。
这种思想不可取，所以scoped_ptr我也不建议使用。

unique_ptr

最后看这位，它也采取了scoped_ptr的方式，删除了拷贝构造和赋值函数。

unique_ptr(const unique_ptr<T>&) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

但是它留了一手，它保留了右值版本的拷贝构造和赋值函数。

unique_ptr(unique_ ptr<T> &&src)
unique_ptr<T>& operator= (const unique_ptr<T>&&)

这样的话，用户在使用unique_ptr的时候必须显示的使用move表明自己知道智能指针的潜在危害。

unique_ptr<int> p1 (new int) ;
unique_ptr<int> p2 (std::move(p1)) ;

这也是不带引用计数的智能指针中，唯一推荐的！！

但是，不带引用计数的方法属实有点笨逼，有没有更好的解决方案？
有！当然有！那就是带引用计数的智能指针呗。

下篇博客我一定介绍带引用计数的智能指针。

参考文献