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

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=sp1
	return 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;
};