自己实现一个智能指针，类比shared_ptr

包括：

构造函数

拷贝构造函数

运算符重载

析构函数

#include <iostream>
#include <assert.h>

using namespace std;

class Person {
public:

	string m_name;
	int m_age;
	
public:
   
	Person() {
		m_name = "hxx";
		m_age = 24;
		cout << "Person的构造函数" << endl;
	}

	~Person() {
		cout << "Person的析构函数" << endl;
	}
};

template<class T>
class smartPointer {

private:
	T* m_ptr;
	size_t* m_count;

public:
	smartPointer(T* p = nullptr) {
		m_ptr = p;
		if (p == nullptr) {
			m_count = new size_t(0);
		}
		else {
			m_count = new size_t(1);
		}
		cout << "智能指针的构造函数" << endl;
	}

	smartPointer(smartPointer& sp) {
		m_ptr = sp.m_ptr;
		m_count = sp.m_count;
		(*m_count)++;
		cout << "智能指针的拷贝构造函数" << endl;
	}

    T* operator->() {
		assert(m_ptr != nullptr);
		return m_ptr;
    }

	T& operator* () {
		assert(m_ptr != nullptr);
		return *m_ptr;
	}

	smartPointer& operator= (smartPointer& sp) {
		if (m_ptr == sp.m_ptr) return *this;

		(*m_count)--;
		if (m_count == 0)
		{
			delete m_ptr;
			delete m_count;
			cout << "智能指针指向的旧对象已释放" << endl;
		}

		m_count = sp.m_count;
		m_ptr = sp.m_ptr;
		(*m_count)++;
		return *this;

	}

	size_t use_count() {
		return *m_count;
	}

	~smartPointer()
	{
		if (m_ptr == nullptr) {
			delete m_count;
			cout << "智能指针的析构函数：指针为空" << endl;
			return;
		}
		(*m_count)--;
		if (*m_count == 0)
		{
			delete m_ptr;
			delete m_count;
			cout << "智能指针的析构函数：智能指针指向的对象已释放" << endl;
		}
	}
	
};

int main()
{
	smartPointer<Person> sp1(new Person());
	cout << sp1->m_name << endl;
	cout << (*sp1).m_age << endl;
	cout << sp1.use_count() << endl;
	smartPointer<Person> sp2(sp1);
	cout << sp1.use_count() << sp2.use_count() << endl;
	smartPointer<Person> sp3;
	sp3 = sp2;
	cout << sp1.use_count() << sp2.use_count() << sp3.use_count() << endl;
}