c++智能指针

异常安全：
如果在malloc和free之间如果存在抛异常，还是会有内存泄漏问题，这种问题就叫做异常安全。
智能指针的使用及原理：
RAII
RAII：是一种利用对象的生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等）的技术
在对象构造时获取资源，接着控制资源的访问，使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，实际上是把管理资源的责任托管给了一个对象，我们可以把这个对象形象的看作是托儿所。
这样以来的话就有两大好处：
1）不需要显示的释放资源，因为我们把资源交给对象管理的时候，对象调用结束后会自动调用析构函数，自动的去释放资源
2）采用这种方式，对象所需的资源在其生命周期内是始终有效的

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);
	vector<int> v(100000000, 10);
}
int main()
{
	try
	{
		int a[5] = { 4, 5, 2, 3, 1 };
		MergeSort(a, 5);
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	system("pause");
	return 0;
}

这个代码中的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;
}
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->_year = 2018;
	sparray->month=1;
	sparray->_day = 1;

}

智能指针的原理：
1.RAII特性
2.重载operator*和operator->，具有像指针一样的行为
std::auto_ptr

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);
	ap->_year = 2018;
	system("pause");
	return 0;
}

auto_ptr存在问题：当对象拷贝或者赋值后，前面的对象就悬空了，因此上述代码运行就会出现程序崩溃
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)
	{
		//首先检查是否自己给自己赋值
		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;
};
struct Date
{
	int _year;
	int _month;
	int _day;
};
int main()
{
	AutoPtr<Date> ap(new Date);
	AutoPtr<Date> copy(ap);
	ap->_year = 2018;
	system("pause");
	return 0;
}

std::unique_ptr：
unique_ptr的实现原理：由于auto_ptr存在的问题是拷贝的过程中导致一个对象被悬空，因此unique_ptr的设计思路就是防拷贝，也就是不让拷贝和赋值
下面是模拟实现：

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:
	UniquePtr(UniquePtr<T>const &);
	UniquePtr& operator=(UniquePtr<T> const&);
	UniquePtr(UniquePtr<T>const&) = delete;
	UniquePtr& operator=(UniquePtr<T>const &) = delete;

};

防拷贝就是把拷贝构造函数和赋值运算符重载函数定义为delete函数
shared_ptr：
shard_ptr的原理：是通过引用计数的方式来实现多个shard_ptr对象之间共享资源
1）shard_ptr在其内部，给每个资源都维护着一份计数，用来记录该份资源被几个对象共享
2）在 对象被销毁时（也就是析构函数调用）就说明自己不该使用该资源的对象，必须释放该资源
3）如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
4）如果不是0，就是说明了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针

//模拟实现shard_ptr
#include<thread>
#include<mutex>
template<class T>
class ShardPtr
{
public:
	ShardPtr(T*  ptr = nullptr)
		:_ptr(ptr)
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{}
	~ShardPtr()
	{
		Release();
	}
	ShardPtr(const ShardPtr<T>& sp)
		:_ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}
	ShardPtr<T>& operator=(const ShardPtr<T>& 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;
	}
	int UseCount()
	{
		return *_pRefCount;
	}
	T* Get()
	{
		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()
{
	ShardPtr<int> sp1(new int(10));
	ShardPtr<int> sp2(sp1);
	*sp2 = 20;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	ShardPtr<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;
	system("pause");
	return 0;
}

std::shared_ptr的线程i安全问题
1）智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2，这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题，所以智能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的
2.智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题

//shared_ptr的循环利用
struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}

};
int main()
{
	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;
	system("pause");
	return 0;
}

循环引用分析：
1）node1和node2两个智能指针对象指向两个节点，引用计数变成1，不需要手动delete
2）node1和_next指向node2，node2的_prev指向node1，引用计数变成2
3）node1和node2析构，引用计数减到1，但是_next还指向下一个结点，但是_prev还指向上一个结点
4）也就是说_next析构了，node2就释放了
5）也就是说_prev析构了，node1就释放了
6）但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放

解决方案：
在引用计数的的场景下，把结点中的_prev和_next改成weak_ptr就可以了
原理就是：node1->_next=node2；和node2->_prev=node1时，weak_ptr的_next和_prev不会增加node1和node2的引用计数。

    struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
	int main()
	{
		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;
		system("pause");
		return 0;

	}

如果不是new出来的对象如何通过智能指针管理呢，shared_ptr设计了一个删除器来解决这个问题。
c++11和boost中智能指针的关系：
1）c++98中产生了第一个智能指针auto_ptr
2）c++boost给出了更实用的scoped_ptr和shared_ptr和wek_ptr
3）c++TR1，引入了shared_ptr等，不过注意的是TR1并不是标准版
4）c++11，引入unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scope_ptr并且这些指针的实现原理是参考boost中的实现的
RAII扩展学习
RAII思想除了可以用来设计智能指针，还可以用来设计守卫锁，防止异常安全导致的死锁问题

#include<thread>
#include<mutex>
//c++11的库中也有一个lock_guard，下面的LockGuard
template<class Mutex>
class LockGuard
{
public:
	LockGuard(Mutex& mtx)
		:_mutex(mtx)
	{
		_mutex.lock();
	}
	~LockGuard()
	{
		_mutex.unlock();
	}
	LockGuard(const LockGuard<Mutex>&) = delete;
private:
	//这里必须使用引用，一个互斥量对象
	Mutex& _mutex;
};
mutex mtx;
static int n = 0;
void Func()
{
	for (size_t i = 0; i < 1000000; ++i)
	{
		LockGuard<mutex> lock(mtx);
		++n;
	}
}
int main(){
	int begin = clock();
	thread t1(Func);
	thread t2(Func);
	t1.join();
	t2.join();
	int end = clock();
	cout << n << endl;
	cout << "cost time:" << end - begin << endl;
	system("pause");
	return 0;
}