【C++】智能指针

内容：

1. 为什么需要智能指针？
2. 几种智能指针的使用及原理

1、为什么需要智能指针？

• malloc，或者new出来的空间没有进行释放，存在内存泄漏的问题；
• 异常安全问题。如果在malloc和free之间（或者new与delete）存在抛异常，那么内存泄漏还是会发生，这种问题就叫做异常安全。

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

2.1 RAII

RAII是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这样做法有两大好处：

• 不需要显式地释放资源；
• 采用这种方式，对象所需的资源在其生命周期内始终保持有效。

//使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr=nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}
private:
	T* _ptr;
};

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	//将tmp指针委托给了sp对象
	SmartPtr<int> sp(tmp);
	//_MergeSort(a,0,n - 1,tmp);

	//这里处理了一些其他逻辑功能
	//.....
}
int main()
{
	//try/catch的功能：catch块会捕捉到try块中的错误
	//并执行代码来处理它，在这里会打印出具体信息
	try
	{
		int a[5] = { 2,1,5,7,9 };
		MergeSort(a, 5);
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

2.2 智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还需要将*、->重载下，才能让其像指针一样去使用。

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}
	T& operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};
struct Date
{
	int _year;
	int _month;
	int _day;
};

int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;
	SmartPtr<int> sparray(new Date);
	//需要注意的是这里应该是sparray.operator->()->_year=2000;
	//本来应该是sparray->->_year,这里语法上为了可读性
	sparray->_year = 2000;
	sparray->_month = 1;
	sparray->_day = 1;
}

总结一下智能指针的原理：

1. RAII特性
2. 重载operator*和operator->，具有像指针一样的行为。

2.3 std::auto_ptr

C++98版本中的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。

#include <memory>
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}

	int _year;
	int _month;
	int _day;
};
int main()
{
	auto_ptr<Date> ap(new Date);
	auto_ptr<Date> copy(ap);

	//auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了
	//C++98中设计的auto_ptr问题是非常明显的，所以实际很多公司明确规定了不能使用auto_ptr
	ap->_year = 2018;
	return 0;
}

auto_ptr的实现原理：管理权限转移的思想，下面简化模拟实现了一份AutoPtr来了解它的原理

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr=NULL)
		:_ptr(ptr)
	{}
	~AutoPtr()
	{
		if (_ptr)
			delete _ptr;
	}

	//一旦发生拷贝，就将ap中资源转移到当前对象中，然后令ap与其所管理资源断开联系
	//这样就解决了一块空间被多个对象使用而造成程序崩溃问题
	AutoPtr(AutoPtr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = NULL;
	}
	
	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		//检测是否为自己给自己赋值
		if (this != &ap)
		{
			//释放当前对象中资源
			if (_ptr)
				delete _ptr;
			 //转移ap中资源到当前对象中
			_ptr = ap._ptr;
			ap._ptr = NULL;
		}
		return *this;
	}

	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};
int main()
{
	AutoPtr<Date> ap(new Date);
	//现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
	//通过ap对象访问资源时就会出现问题
	AutoPtr<Date> copy(ap);
	ap->_year = 2000;

	return 0;
}

2.4 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

int main()
{
	unique_ptr<Date> up(new Date);

	//unique_ptr的设计思路非常的粗暴---防拷贝，也就是不让拷贝和赋值
	unique_ptr<Date> copy(ap);

	return 0;
}

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份uniqueptr来了解它的原理

template<class T>
class UniquePtr
{
public:
	UniquePtr(T* ptr=nullptr)
		:_ptr(ptr)
	{}
	~UniquePtr()
	{
		if (_ptr)
			delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	//C++98防拷贝的方式：只声明不实现+声明成私有
	UniquePtr(UniquePtr<T> const&);
	UniquePtr & operator=(UniquePtr<T> const &);

	//C++11防拷贝的方式：delete
	UniquePtr(UniquePtr<T> const&) = delete;
	UniquePtr & operator=(UniquePtr<T> const &) = delete;
private:
	T* _ptr;
};

2.5 std::shared_ptr

C++11中开始提供更靠谱并且支持拷贝的shared_ptr

int main()
{
	//shared_ptr通过引用计数支持智能指针对象的拷贝
	shared_ptr<Date> sp(new Date);
	shared_ptr<Date> copy(sp);

	cout << "ref count:" << sp.use_count() << endl;
	cout << "ref count:" << copy.use_count() << endl;
	return 0;
}

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间资源共享。例如：同一间教室的人共享一个电灯，最后一位同学离开时关灯。

1. shared_ptr在其内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象共享；
2. 在对象被销毁时(也就是析构函数调用)，说明自己不使用该资源了，对象的引用计数减一；
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

//模拟实现一份简单的sharedptr
#include <thread>
#include <mutex>
template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr=nullptr)
		:_ptr(ptr)
		,_pRefCount(new int(1))
		,_pMutex(new mutex)
	{}
	~SharedPtr()
	{
		Release();
	}
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}

	//sp1 = sp2
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		//if(this!=&sp)
		if (_ptr != sp._ptr)
		{
			//释放管理的旧资源
			Release();

			//共享管理新对象的资源，并增加引用计数
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;

			AddRefCount();
		}
		return *this;
	}

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

	void AddRefCount()
	{
		//加锁或者使用加1的原子操作
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
	}

private:
	void Release()
	{
		bool deleteflag = false;
		//引用计数减1，如果减到0，则释放资源
		_pMutex->lock();
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
			deleteflag = true;
		}
		_pMutex->unlock();

		if (deleteflag == true)
			delete _pMutex;
	}

private:
	int* _pRefCount;//引用计数
	T* _ptr;//指向管理资源的指针
	mutex* _pMutex;//互斥锁
};

int main()
{
	SharedPtr<int> sp1(new int(10));
	SharedPtr<int> sp2(sp1);
	*sp2 = 20;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	SharedPtr<int> sp3(new int(10));
	sp2 = sp3;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	cout << sp3.use_count() << endl;

	sp1 = sp3;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	cout << sp3.use_count() << endl;
	return 0;
}

以上为总结的几种智能指针的使用及原理，但是对于shared_ptr其实还存在一些问题，下一篇继续讨论。