c++11：智能指针

目录

前言

智能指针的使用

RAII

 demo

auto_ptr

unique_ptr

shared_ptr

weak_ptr

智能指针的原理

---

前言

智能指针是c++11中很好用的一个东西，很好的解决的资源泄露的问题。

智能指针的使用

RAII

Resource Acquisition Is Initialization ,获取资源的最好的时机就是初始化。

就是利用对象的生命周期来进行资源的管理。

重新理解下获取资源的最好的时机就是初始化，当申请好资源，立即将资源放到对象里进行管理。

妈妈再也不用担心忘记释放内存啦，因为当对象生命周期到了的时候，调用其析构函数自动将资源释放。

 demo

auto_ptr

#include<iostream>
#include<memory>
using namespace std;


int main()
{
	auto_ptr<int> ptr1 (new int[5]);
    auto_ptr<int> ptr2 = ptr1;//ptr1 = nullptr
	return 0;
}

注意：auto_ptr有一个很坑的地方就是，若将ptr1赋值给ptr2，这时候ptr1就会为空。

unique_ptr

与auto_ptr的区别就是禁止拷贝。

shared_ptr

shared_ptr，没有了auto_ptr的赋值问题，因为shared_ptr多了一个引用计数，每次拷贝和赋值时，引用计数都会++，析构时--，当引用计数为0时，析构释放资源。

#include<iostream>
#include<memory>
using namespace std;


int main()
{
	shared_ptr<int> ptr1 (new int[5]);
	shared_ptr<int> ptr2 = ptr1;
	shared_ptr<int> ptr3(ptr2);
	return 0;
}

注意：shared_ptr也有一个地方需要注意，环形指针的循环引用。

在循环引用的情况下，shared_ptr会导致资源的泄露。

template<class T>
struct ListNode
{
	ListNode(T dt)
		:data(dt)
	{}
	T data;
	shared_ptr<ListNode<T>> next = nullptr;
	shared_ptr<ListNode<T>> prev = nullptr;
};

int main()
{
	//环形引用问题
	shared_ptr<ListNode<int>> ptr1 = new ListNode<int>(1);
	shared_ptr<ListNode<int>> ptr2 = new ListNode<int>(2);
	ptr1->next = ptr2;
	ptr2->prev = ptr1;
	return 0;
}

在main结束的时候，ptr2先销毁，ptr2的count--，目前ptr2的count = 1。

ptr1再销毁，ptr1的count--，目前ptr1的count = 1。

程序结束，资源并没有释放，引用计数没有减为0，因为ptr1.next还指向ptr2，ptr2.prev指向ptr1。 

weak_ptr

weak_ptr并不是一个RAII，weak_ptr不析构资源，weak_ptr可以解决shared_ptr环形引用的问题，环形引用不能析构的主要原因不就是引用计数的锅吗？

template<class T>
struct ListNode
{
	ListNode(T dt)
		:data(dt)
	{}
	T data;
	sp::weak_ptr<ListNode<T>> next = sp::shared_ptr<ListNode<T>>(nullptr);
	sp::weak_ptr<ListNode<T>> prev = sp::shared_ptr<ListNode<T>>(nullptr);

};

int main()
{
	//环形引用问题
	sp::shared_ptr<ListNode<int>> ptr1 = new ListNode<int>(1);
	sp::shared_ptr<ListNode<int>> ptr2 = new ListNode<int>(2);
	
	ptr1->next = ptr2;
	ptr2->prev = ptr1;

	return 0;
}

使用weak_ptr之后，next和prev就不再引用计数了， 

智能指针的原理

我只写的一个最难的shared_ptr，其他的都一样的。

template<class T>
	class shared_ptr
	{
	private:
		void release()
		{
			if (--(*_count) == 0)
			{
				cout << "delete " << endl;
				delete _ptr;
				delete _count;
			}
		}

	public:
		shared_ptr()
			:_ptr(nullptr)
		{
			_count = new int(0);
		}

		shared_ptr(T * ptr)
			:_ptr(ptr)
		{
			if(ptr != nullptr)
			{
				_count = new int(1);
			}
			else
			{
				_count = new int(0);
			}
		}

		//拷贝构造
		shared_ptr(const shared_ptr<T> &ptr)
		{
			_ptr = ptr._ptr;
			_count = ptr._count;
			(*_count)++;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& ptr)
		{
			//先将当前对象释放，在赋值
			
			//处理自我赋值
			if (ptr._ptr != _ptr)
			{
				release();
				_ptr = ptr._ptr;
				_count = ptr._count;
				(*_count)++;
			}

			return *this;
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		~shared_ptr()
		{
			release();
		}

		T* get() const
		{
			return _ptr;
		}

	private:
		T * _ptr;//
		int* _count;//引用计数
	};

我总结下来主要有3️⃣点值得注意

1.引用计数是不可以使用，静态的变量的，这是一个误区，静态变量属于所有的对象，

如果想统计有多少个对象，使用静态没毛病，但是想要统计这块资源，有多少个smart_ptr指向，是不可以的，引用计数必须是动态开辟的。

2.operator=()时需要处理自我赋值，如果判断语句使用ptr != this是不够好的，因为间接的自我赋值，这个是查不出来的，直接使用原生指针判断是最好的办法。

3..operator=()一定要，先将当前对象析构，因为赋值不像拷贝构造，拷贝构造一定是一个未初始化的对象，但是赋值不一定啊，当前对象可能也会指向其他的资源呢，不调用析构，引用计数不--，资源就又泄露了