智能指针

RAII
RAII是一种利用对象生命周期来控制程序资源的技术

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终有效，最后在对象析构的时候释放资源，实际上是将一份资源的责任托管给了一个对象，这样做呢，就不需要显式释放资源，采用这种方法，对象所需资源在其生命周期内始终有效。

智能指针原理：

• RAII特性
• 重载operator* 和operator-> ,使其具有像指针一样的行为

auto_ptr

C++98提供的智能指针，包含在memory头文件中
auto_ptr的实现原理：管理权转移的思想
auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了

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

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

	int _year;    
	int _month;   
	int _day;
};

int main() {
	AutoPtr<Date> ap(new Date);        
	// 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空  							   
	// 通过ap对象访问资源时就会出现问题。    
	AutoPtr<Date> copy(ap);    
	ap->_year = 2018; //此处修改就会出错，ap已经是一个空指针了
	return 0;
}

unique_ptr

C++11提供的更靠谱的unique_ptr
unique_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:
	//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;
};

shared_ptr

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

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

//模拟实现shared_ptr
#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();    
 		}

	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; }
 
 	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;      // 互斥锁  

shared_ptr的线程安全问题

shared_ptr的线程安全分为两方面：

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