【c++智能指针】

目录

  • 一、智能指针的使用及原理
  • 二、auto_ptr
  • 三、unique_ptr
  • 三、shared_ptr
  • 四、weak_ptr
  • 五、定制删除器

一、智能指针的使用及原理

RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处:
不需要显式地释放资源。
采用这种方式,对象所需的资源在其生命期内始终保持有效。
比如:为什么智能指针前:

#include"smartptr.h"
class A
{
public:
	A(int a)
		:_a(a)
	{
		//cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	//Ting::SmartPtr sp1(new A(10));
	//Ting::SmartPtr sp2(new A(20));
	A* a = new A(10);
	cout << div() << endl;
}
int main()
{
	try {
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

【c++智能指针】_第1张图片
使用后:

#include
using namespace std;

namespace Ting
{
	template<class T>
	class SmartPtr
	{
	public:
		SmartPtr(const T* ptr)
			:_ptr(ptr)
		{}

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

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

		~SmartPtr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

	private:
		const T* _ptr;
	};
}
#include"smartptr.h"
class A
{
public:
	A(int a)
		:_a(a)
	{
		//cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	Ting::SmartPtr<A> sp1(new A(10));
	Ting::SmartPtr<A> sp2(new A(20));
	//A* a = new A(10);
	cout << div() << endl;
}
int main()
{
	try {
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

【c++智能指针】_第2张图片

二、auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
【c++智能指针】_第3张图片
模拟实现auto_ptr:

template<class T>
class auto_ptr
{
public:
	auto_ptr (T* ptr)
		:_ptr(ptr)
	{}

	auto_ptr(auto_ptr<T>& ap)
	{
		_ptr = ap._ptr;
		//悬空
		ap._ptr = nullptr;

	}

	auto_ptr<T>& operator=(auto_ptr<T>& ap)
	{
		if (_ptr != ap._ptr)
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = ap._ptr;
			//悬空
			ap._ptr = nullptr;
		}
		return *this;

	}

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

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

	~auto_ptr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}

private:
	T* _ptr;
};
 // 结论:auto_ptr是一个失败设计,很多公司明确要求不能使用auto_ptr
 //int main()
 //{
 //  std::auto_ptr sp1(new int);
 //  std::auto_ptr sp2(sp1); // 管理权转移
//
 //  // sp1悬空
//  *sp2 = 10;
 //  cout << *sp2 << endl;
 //  cout << *sp1 << endl;
 //  return 0;
 //}

三、unique_ptr

为了解决上面auto_ptr拷贝赋值后因为管理权限转移而造成悬空问题,C++11引入了unique_ptr
unique_ptr的实现原理:简单粗暴的防拷贝,下面简化模拟实现了一份UniquePtr来了解它的原理

template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

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


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

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

		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

	private:
		T* _ptr;
	};

三、shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理:是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  1. shared_ptr在其内部,给每个资源都维护了着一份计数,用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用),就说明自己不使用该资源了,对象的引用计数减一。
  3. 如果引用计数是0,就说明自己是最后一个使用该资源的对象,必须释放该资源;
  4. 如果不是0,就说明除了自己还有其他对象在使用该份资源,不能释放该资源,否则其他对象就成野指针了。
    下面简化模拟实现了一份shared_ptr来了解它的原理
template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr)
		:_ptr(ptr)
		,_pcount(new int(1))
	{}

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

	shared_ptr<T>& operator=(shared_ptr<T>& sp)
	{
		//防止自己给自己赋值
		if (_ptr != sp._ptr)
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			++(*_pcount);
		}
		return *this;
	}

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

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

	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
	int* _pcount;
};

但是shared_ptr再有些场景下会出现循环引用问题。如:
【c++智能指针】_第4张图片
没有调用Node的析构函数。为什么呢?如图:
【c++智能指针】_第5张图片

四、weak_ptr

为了解决shared_ptr循环引用场景,所以又引入了weak_ptr。
【c++智能指针】_第6张图片
下面简化模拟实现了一份weak_ptr来了解它的原理

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}

	weak_ptr(Ting::shared_ptr<T>& sp)
		:_ptr(sp.get())
	{}

	weak_ptr<T>& operator=(Ting::SmartPtr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

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

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

private:
	T* _ptr;
};

五、定制删除器

上面模拟的shared_ptr只能在少部分场景下使用,在这个场景下使用不了。如:
【c++智能指针】_第7张图片
所以我们可以模拟库里在构造时加个仿函数过去。
【c++智能指针】_第8张图片
属性里也加个,用包装器来申明。
【c++智能指针】_第9张图片
析构函数改成调用仿函数。
【c++智能指针】_第10张图片
完整代码:

template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr)
		:_ptr(ptr)
		, _pcount(new int(1))
	{}

	template<class D>
	shared_ptr(T* ptr,D del)
		:_ptr(ptr)
		,_pcount(new int(1))
		,_del(del)
	{}

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

	shared_ptr<T>& operator=(shared_ptr<T>& sp)
	{
		//防止自己给自己赋值
		if (_ptr != sp._ptr)
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			++(*_pcount);
		}
		return *this;
	}

	~shared_ptr()
	{
		if (--(*_pcount) == 0)
		{

			_del(_ptr);
			delete _pcount;
		}
	}

	T* get()
	{
		return _ptr;
	}

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

	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
	int* _pcount;
	function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

你可能感兴趣的:(c++)