模拟实现shared_ptr

• 一个资源可由多个对象管理
• 有多少个对象管理资源,引用计数就是几
• 会造成循环引用的问题

//shared_ptr
template <class T>
class sharedPtr{
public:
	//构造函数
	sharedPtr(T* ptr = nullptr)
	:_ptr(ptr)
	,_pmt(new mutex)
	,_ptrCount(new int(0)){
		if (_ptr){
			addPtrCount();
		}
		cout << "构造->当前引用计数为 :" << *_ptrCount << endl;
	}
	void addPtrCount(){
		(*_pmt).lock();
		++*_ptrCount;
		(*_pmt).unlock();
	}

	//拷贝构造
	sharedPtr(sharedPtr<T>& ap)
		:_ptr(ap._ptr)
		, _ptrCount(ap._ptrCount)
		,_pmt(ap._pmt){
		if (ap._ptr)
			addPtrCount();
		cout << "拷贝->当前引用计数为 :" << *_ptrCount << endl;
	}

	//赋值运算符重载
	sharedPtr<T>& operator=(sharedPtr<T>& ap){
		//是否是自己给自己赋值
		if (this != &ap){
			//先释放原来的
			clearCount();
			_ptr = ap._ptr;
			_ptrCount = ap._ptrCount;
			_pmt = ap._pmt;
			if (ap._ptr)
				addPtrCount();
		}
		cout << "赋值->当前引用计数为 :" << *_ptrCount << endl;
		return *this;
	}

	//重载*
	sharedPtr<T>& operator*(){
		return *_ptr;
	}

	//重载->
	sharedPtr<T>* operator->(){
		return _ptr;
	}

	//清理资源
	void clearCount(){
		if (_ptr){
			//当前对象是最后一个管理资源的
			if (*_ptrCount == 1){
				cout << "直接析构->当前引用计数为 :" << *_ptrCount << endl;
				delete _ptr;
				_ptr = nullptr;
			}
			else{
				(*_pmt).lock();
				cout << "析构前->当前引用计数为 :" << *_ptrCount << endl;
				--*_ptrCount;
				(*_pmt).unlock();
			}
		}
	}

	//析构函数
	~sharedPtr(){
		clearCount();
	}
private:
	T* _ptr;
	int* _ptrCount;
	mutex* _pmt;//保证操作引用计数是原子操作
};



int main(){
	sharedPtr<int> sp1;//没有管理资源
	sharedPtr<int> sp2(sp1);//没有管理资源
	sharedPtr<int> sp3(new int(10));//引用计数1
	sp1 = sp3;//引用计数2
	sp2 = sp3;//引用计数3
	return 0;
}