C++智能指针

#include<iostream>
using namespace std;

#if 0
void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;

	int mid = left + ((right - left) >> 1);
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);

	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
			tmp[index++] = a[begin1++];
		else
			tmp[index++] = a[begin2++];
	}

	while (begin1 <= end1)
		tmp[index++] = a[begin1++];

	while (begin2 <= end2)
		tmp[index++] = a[begin2++];

	memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
}
//
//void MergeSort(int* a, int n)
//{
//	int* tmp = (int*)malloc(sizeof(int) * n);
//	_MergeSort(a, 0, n - 1, tmp);
//
//}

#include<vector>
template<class T>
class SmarPtr
{
public:
	SmarPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmarPtr()
	{
		if (_ptr)
			delete _ptr;
	}
private:
	T* _ptr;
};

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);

	SmarPtr<int> sp(tmp);
	_MergeSort(a, 0, n - 1, tmp);

	vector<int> v(1000000000000, 10);
}

int main()
{
	try
	{
		int a[5] = { 4,5,3,2,1 };
		MergeSort(a, 5);
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}
#endif


#if 0
//std::auto_ptr
#include<memory>
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}


	int _year;
	int _mouth;
	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 = 1;

	return 0;
}
#endif 

#if 0
//auto_ptr的实现原理：管理权转移的思想。
//模拟实现：

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)
	{
		//是要把ap 赋值 给_ptr。
		//防止自己给自己赋值
		if (this != &ap)
		{
			//如果_ptr不为空，则说明它正管理着其它空间，
			//先把_ptr中的对象释放，不然会造成内存泄漏
			if (_ptr)
				delete _ptr;

			//再赋值
			_ptr = ap._ptr;
			
			ap._ptr = NULL;
		}

		return *this;
	}

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

class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}


	int _year;
	int _mouth;
	int _day;
};

int main()
{
	AutoPtr<Date>ap(new Date);
	//AutoPtr<Date>copy(ap);
	AutoPtr<Date>aap(new Date);
	aap = ap;
	ap->_year = 2019;
	
	//ap.operator->()->_year = 2019;// 本应改是这样的
							

	return 0;
}
#endif


#if 0
//std::unque_ptr  == boost::scoped_ptr
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}


	int _year;
	int _mouth;
	int _day;
};

//模拟实现
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:
#if 0
	//C++98防拷贝的方式，只声明不实现+声明成私有的
	UniquePtr(UniquePtr<T> const&);
	UniquePtr& operator=(UniquePtr<T> const&);
	//UniquePtr<T> operator=(UniquePtr<T> const&);
#endif
	//	C++11防拷贝方式:delete （公有私有都可以）
	UniquePtr(UniquePtr<T> const&) = delete;
	UniquePtr& operator= (UniquePtr<T> const&) = delete;
	//UniquePtr<T> operator= (UniquePtr<T> const&) = delete;

private:
	T* _ptr;
};


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

	//unique_ptr 的设计思维非常粗暴-防拷贝， 也就是不让拷贝和赋值。
	//unique_ptr<Date> copy(up);
	//..
	UniquePtr<Date> up(new Date);
	UniquePtr<Date> copy(up);
	UniquePtr<Date> cup(new Date);
	cup = up;

	return 0;
}
#endif 0


//std::shared_ptr 通过引用计数支持智能指针对象的拷贝
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}


	int _year;
	int _mouth;
	int _day;
};

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

//模拟实现
//因为++/--不是一个原子操作，所以引用计数的++/--会引发线程安全问题,因此需要加锁.
#include<mutex>
template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		:_ptr(ptr)
		,_count(new int(1))
		,_mutex(new mutex)
	{}
	~SharedPtr()
	{
		Release();
	}
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
		,_mutex(sp._mutex)
	{
		AddCount();
	}
	//*this = sp
	SharedPtr<T>& operator= (const SharedPtr<T>& sp)  //这两个有什么区别？
	//SharedPtr& oeprator= (const SharedPtr<T>& sp)
	{
		//if (this != &sp)
		if(_ptr != sp._ptr)
		{
			//释放管理的旧资源
			Release();

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

			AddCount();
		}

		return *this;
	}
	T& operator* ()
	{
		return *_ptr;
	}
	T* operator-> ()
	{
		return _ptr;
	}
	void AddCount()
	{
		//加锁或者使用加1的原子操作
		_mutex->lock();
		++(*_count);
		_mutex->unlock();
	}
	int UseCount()
	{
		return *_count;
	}
private:
	void Release()
	{
		bool deleteflag = false; //设一个标签,为了最后释放_mutex

		//引用计数减一，如果减到0，则释放资源
		_mutex->lock();
		if (--(*_count) == 0) //前置--,先--再判断
		{
			delete _ptr;
			delete _count;
			deleteflag = true;
		}
		_mutex->unlock();

		if (deleteflag == true)
			delete _mutex;
	}
private:
	T* _ptr;
	int* _count; //引用计数，因为要多个对象同这个计数操作，因此得是int*
	mutex* _mutex;  //1.互斥锁, 为了线程安全
		//2. 智能指针管理的对象是存放在堆上的，两个线程同时去访问，会导致线程安全问题
};


//shared_ptr存在循环引用的问题

struct ListNode
{
	int _data;
	//shared_ptr<ListNode> _prev;
	//shared_ptr<ListNode> _next;

	//为了解决shared_ptr的循环引用问题,使用了weak_ptr，他是一个弱指针。
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	//解决方案：在引用计数的场景下，把节点中的_prev和_next改成
	//weak_ptr就可以了
	//原理就是，node1->_next = node2;和node2->_prev = node1时
	//weak_ptr的_next和_prev不会增加node1和node2的引用计数

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

//如果不是new出来的对象如何通过智能指针管理呢？
//其实shared_ptr设计了一个删除器来解决这个问题

//仿函数删除器
#include <stdlib.h>
template<class T>

struct FreeFunc
{
	void operator() (T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc
{
	void operator() (T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};


int main()
{
	//shared_ptr<Date> sp(new Date);
	//shared_ptr<Date> copy(sp);

	//cout << sp.use_count() << endl;
	//cout << copy.use_count() << endl;

	//..
	//SharedPtr<int> sp1(new int(10));
	//SharedPtr<int> sp2(sp1);
	//*sp2 = 20;
	//cout << sp1.UseCount() << endl;
	//cout << sp2.UseCount() << endl;

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

	//sp1 = sp3;
	//cout << sp1.UseCount() << endl;
	//cout << sp2.UseCount() << endl;
	//cout << sp3.UseCount() << endl;

	//..
	//shared_ptr<ListNode> node1(new ListNode);
	//shared_ptr<ListNode> node2(new ListNode);
	//cout << node1.use_count() << endl;
	//cout << node2.use_count() << endl;

	//node1->_next = node2;
	//node2->_prev = node1;
	//cout << node1.use_count() << endl;
	//cout << node2.use_count() << endl;

	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);

	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);


	return 0;
}