波奇学C++：智能指针(二)：auto_ptr, unique_ptr, shared_ptr,weak

C++98到C++11：智能指针分为auto_ptr, unique_ptr, shared_ptr，weak_ptr,这几种智能都是为了解决指针拷贝构造和赋值的问题

auto_ptr：允许拷贝，但只保留一个指向空间的指针。

管理权转移，把拷贝对象的资源管理权转移给拷贝对象，导致被拷贝对象悬空，不能访问出问题 ap1置空

auto_ptr<Test> ap1(new Test());
auto_ptr<Test> ap3 = ap1;
// ap1=nullptr

如果不置空就会导致对象调用析构函数时，空间会被释放两次。但会导致ap1无法再使用。

模拟auto_ptr

template<class T>
class AutoPtr
{
public:AutoPtr(T* ptr):_ptr(ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~AutoPtr(){cout << "delete pointer" << _ptr << endl;delete _ptr;}AutoPtr(AutoPtr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}
private:T* _ptr;
};

unique_ptr: 禁止拷贝

unique_ptr<A> up1(new A());
unique_ptr<A> up3=up1// 报错

模拟实现unique_ptr

template<class T>
class UniquePtr
{
public:UniquePtr(T* ptr):_ptr(ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~UniquePtr(){cout << "delete pointer" << _ptr << endl;delete _ptr;}UniquePtr(const UniquePtr<T>& up) = delete; // 禁止拷贝构造UniquePtr<T>& operator=(const UniquePtr<T>& up) = delete; //禁止默认生成赋值重载函数
private:T* _ptr;
};

shared_ptr：支持拷贝，无法解决循环引用

shared_ptr通过引用计数来防止被多次析构

引用计数

用一个变量来记录指向空间的指针数，当一个智能指针释放时，变量数值减一，当数值为0时才释放空间。

模拟share_ptr的实现

template<class T>
class SharedPtr
{
public:SharedPtr(T* ptr):_ptr(ptr),_pcount(new int(1)){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~SharedPtr(){if (--(*_pcount) == 0){cout << "delete pointer" << _ptr << endl;delete _ptr;delete _pcount;}}private:T* _ptr;int* _pcount;
};

shared_ptr的拷贝构造

SharedPtr(const SharedPtr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){(*_pcount)++;}

shared_ptr的赋值重载

SharedPtr<T>& operator=(const SharedPtr<T>& sp){if (_ptr==sp._ptr){return *this;}if (*_pcount == 1){~SharedPtr();}else{(*_pcount)--;}*(sp._pcount)++;_pcount = sp._count;_ptr = sp._ptr;return *this;}

循环引用问题

class Test
{
public:Test(){cout << "构造函数"<<" "<<this << endl;}Test* fun(){return this;}~Test(){cout << "析构" << endl;}};
struct Node
{Test test;shared_ptr<Node> _next;shared_ptr<Node> _prev;
};
int main()
{shared_ptr<Node> sp1(new Node);shared_ptr<Node> sp2(new Node);sp1->_next = sp2;sp2->_prev=sp1return 0;
}

当sp1 和sp2析构时，引用计数减为1

当要释放左边空间->释放右边空间的_prev->释放左边的_next->释放左边的空间。

释放左边空间->释放左边空间

形成死循环无法解决。

weak_ptr：解决shared_ptr循环引用问题，不属于RAII智能指针

struct Node
{Test test;weak_ptr<Node> _next;weak_ptr<Node> _prev;
};

weak_ptr:解决原理不增加引用计数

template<class T>
class WeakPtr
{
public:WeakPtr():_ptr(nullptr){}WeakPtr(const SharedPtr<T>& sp):_ptr(sp._ptr){}WeakPtr<T>& operator= (SharedPtr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};