【C++11】智能指针问题

---

---

---

RAII

RAII就是将资源交给一个对象管理，这个对象能进行正常的管理和释放资源。

一、auto_ptr

auto_ptr的问题是：在拷贝构造和赋值重载时，会将自己资源的管理权转移给对方。

template<class T>
class auto_ptr
{
public:

	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}

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

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

	//ap3(ap1)
	auto_ptr(auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;//必须置空，否则两个指针对象管理同一块空间，会调用析构两次
	}
	
	operator=(auto_ptr<T>& ap)
	{
	    _ptr = ap._ptr;
	    ap._ptr = nullptr;
	}

	~auto_ptr()
	{
		delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理
		//自定义类型调用它自己的析构
		_ptr = nullptr;
	}
private:
	T* _ptr;
};

这个auto_ptr实际不会用，太挫了。
但面试可能要手撕，也要会。

二、unique_ptr

unique_ptr 简单粗暴地禁止了拷贝和赋值重载，那就解决了上面auto_ptr的管理权转移问题了。

template<class T>
	class unique_ptr
	{
	public:

		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

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

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

		unique_ptr(unique_ptr<T>& up) = delete;
		unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;
		~unique_ptr()
		{
			delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理
			//自定义类型调用它自己的析构
			_ptr = nullptr;
		}
	private:
		T* _ptr;
	};

所以unique_ptr就比较适用于，一个指针独占一个资源的情况。

三、shared_ptr

shared_ptr使用了引用计数器，最开始new对象时，计数器为1。
而当其他的同类型的指针对象也指向该对象时，计数器+1。
当有指针对象调用析构函数时，判断计数器是否为0，如果不为0，表明我这个对象还有其他的shared_ptr在管理，不需要delete，让计数器-1即可。
如果计数器为0，表明当前的shared_ptr是最后一个指针对象管理资源了。就delete。

shared_ptr解决了auto_ptr的管理权转移问题，也解决了unique_ptr的不让拷贝和赋值的问题。

注意的问题：

• 1.不能赋值给自己，否则计数器会++。
  还有一个问题：默认的析构函数的处理方式是delete ptr。
  如果指针管理的资源是T[]，或者是fopen，或者是malloc的呢？
  如果还使用默认的处理方式delete ptr，就会出现问题。
  资源是T[],就得用delete[] ,是fopen，就得用fclose，是malloc，就得用free。
  所以在传参的时候，就需要传处理方法过来了。（可以传对象的方法，可以传lambda，可以传包装器。
  所以就需要将析构函数，设置成一个对象/包装器，调用的就是传进来的析构方法。
• 2.实现赋值重载的时候，有很多细节。
• • 不能自己给自己赋值
• • 在把对方赋值给自己之前，需要把自己所指向的计时器减减，因为我要只向其他的计时器了。如果减减后的计时器为0，说明这块资源只有我一个指针在管理，现在我要只想其他资源，所以我要先释放我现在的资源才能去指向其他资源，否则就会出现内存泄露问题。
    

template<class T>
	class shared_ptr
	{
	public:

		//1) 使用定制删除器，解决一个当new []时，需要delete []的问题
		//2) 还有 使用malloc时，需要free配对
		//3) 使用fopen，需要fclose配对

		template<class D>
		shared_ptr(T* ptr,D del)
			:_ptr(ptr)
			,_pcount(new int(1))
			,_del(del)
		{}
		//然而这里有一个问题，模板D不是全局的，而是只针对这个构造函数
		//所以应该如何创建_del对象呢？

		//使用包装器
		//function <void(T*)> _del;
		//因为不管是上面三种情况的哪一种，共同点都是使用的仿函数的返回值都是void，指针类型都是T*


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

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

		//sp3(sp1)
		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			,_pcount(sp._pcount) //让他们的引用计数器指针指向同一个计数器
		{
			++(*_pcount);
		}

		//sp5 = sp2
		shared_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			//不能自己赋值给自己，否则引用计数器会++
			//这样判断是可以的，只要不同的对象指向同一个资源空间，这几个对象之间的赋值都是相当于自己给自己赋值
			if(_ptr == sp._ptr)  
			//if (_pcount == sp._pcount) //这也可以
			{
				return *this;
			}
			//赋值前，需要将之前的计数器--，如果计数器为0，就释放资源
			//因为我要指向其他资源了，我原来的资源的计数器当然要--
			if (--(*sp._pcount) == 0)
			{
				_del(sp._ptr);
				delete sp._pcount;
			}

			_ptr = sp._ptr;
			_pcount = sp._pcount;

			++(*_pcount);

			return *this;
		}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				_del(_ptr);
				delete _pcount;
				_pcount = nullptr;
				_ptr = nullptr;
			}
		}

		T* get() const 
		{
			return _ptr;
		}

		int use_count() const 
		{
			return *_pcount;
		}
	private:
		T* _ptr;
		int* _pcount;
		//包装器
		//包装器包装的_del是D类型，这个D也不知道是什么类型，
		//包装器可以包装仿函数，包装对象的方法等。
		//如果只是普通的指针析构，那就给一个缺省。
		function <void(T*)> _del = [](T* ptr) {delete ptr; }; 
		//dzt::shared_ptr<int> svr(new int); //这样的方式，就是没传处理方式，那默认就是用缺省。
		//dzt::shared_ptr<int> svr(new int[10],[](int* ptr){delete[] ptr};
		//这样的传参方式，就用delete[]解决
	};

shared_ptr的循环引用问题

循环引用问题是两个节点的shared_ptr指针互相指向的时候，引用计数器都会+1，这就出现了互相的计数器都是2.在析构时，都变成1，此时就出现了，到底谁先析构的问题。
就一直死循环了。

不过，shared_ptr能解决日常生活99%的问题，它只有一个缺点，就是循环引用问题。

解决办法：weak_ptr，weak_ptr是专门解决循环引用这个问题的。
weak_ptr没有RAII，没有引用计数，不参与对象资源的管理和释放，只是一个简单的访问资源的操作。

四、weak_ptr

template<class T>
	class weak_ptr
	{
	public:

		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(T* ptr)
			:_ptr(ptr)
		{}

		//weak_ptr必须支持一个shared_ptr构造weak_ptr的构造函数
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//类外面无法直接访问类的私有成员
			_ptr = sp.get();
			return *this;
		}

		//weak只支持访问资源的操作
		T& operator*()
		{
			return *_ptr;
		}

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

		//weak_ptr不参与对象资源的管理和释放，所以没有析构函数
		
	private:
		T* _ptr;
	};

---

总结

本文讲述了几个智能指针的优缺点和模拟实现。