实现一个带引用计数的shared_ptr智能指针

*自定义一个myShared_ptr结构，包含引用计数、运算符、->运算符

// 自定义 shared_ptr 智能指针
template<class T>
class myShared_ptr {
public:
	// 构造函数
	myShared_ptr(T* ptr) :
		_ptr(ptr), _pCount(new int(1)) {}
	// 拷贝构造函数
	myShared_ptr(const myShared_ptr& sp) :
		_ptr(sp._ptr), _pCount(sp._pCount) {
		(*_pCount)++;
	}
	// 赋值构造函数
	myShared_ptr& operator=(myShared_ptr<T>& sp) {
		if (this->_ptr != sp._ptr) {	// 左右ptr值不等
			if (--(*_pCount) == 0) {	// 左值的计数器 -1	, 若减后为0，释放对象
				delete _ptr;
				delete _pCount;
			}
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			(*_pCount)++;	// 右值计数器 +1
		}
		return *this;	// 左右ptr值
	}
	// 析构函数
	~myShared_ptr() {
		if (--(*_pCount) == 0) {
			delete _ptr;
			delete _pCount;
		}
	}
	// *运算符
	T& operator*() {
		return *_ptr;
	}
	// -> 运算符
	T* operator->() {
		return _ptr;
	}
	// 使用次数
	int use_count() {
		return *_pCount;
	}

private:
	T* _ptr;		// T* 类型指针
	int* _pCount;	// 引用计数
};

再定义一个类Person，Person在析构时，会有提示 ：

struct Person {
	int x;
	Person(int val) :
		x(val) { }
	~Person() {
		cout << " DECONSTRUCTION !" << endl;
	}
	int print() {
		return x;
	}
};

主函数，验证：

int main(){
	myShared_ptr<Person> msp1(new Person(1));
	cout << "(*msp1).print() = " << (*msp1).print() << endl;
	cout << "count of msp1   = " << msp1.use_count() << endl;
	myShared_ptr<Person> msp2(new Person(2));
	msp1 = msp2;												// msp1 会析构一次
	cout << "count of msp1   = " << msp1.use_count() << endl;
	cout << "(*msp1).print() = " << (*msp1).print() << endl;
}	// 退出主程序main{} 范围后，Person会析构一次

运行结果：