使用引用计数实现最简单的智能指针2

使用模板技术完善智能指针，将引用计数封装到类中

#include <iostream>
#include <string>
using namespace std;

template<class T>
class CSmartPtr;

template<class T>
class CRefCount
{
public:
	friend class CSmartPtr<T>;
	CRefCount(T *stu)
	{
		m_stu = stu;
		++m_count;
	}

	~CRefCount()
	{
		delete m_stu;
		m_stu = nullptr;
		m_count = 0;
	}

	int release(void)
	{
		
		if (--m_count == 0)
		{
			cout << "m_count =" << m_count << endl;
			delete this;
		}
		return 0;
	}

	int addref(void)
	{
		++m_count;
		return 0;
	}

private:
	int m_count = 0;
	T *m_stu = nullptr;
};

template<class T>
class CSmartPtr
{
public:
	CSmartPtr() = delete;

	CSmartPtr(T *stu)
	{
		m_ref = new CRefCount<T>(stu);
 	}

	CSmartPtr(CSmartPtr &obj)
	{
		m_ref = obj.m_ref;
		m_ref->addref();
	}

	CSmartPtr &operator=(CSmartPtr &obj)
	{
		if (m_ref == obj.m_ref)
		{
			return *this;
		}
		if (m_ref != nullptr)
		{
			m_ref->release();
		}

		m_ref = obj.m_ref;
		m_ref->addref();
		return *this;
	}

	T *operator->()
	{
		return m_ref->m_stu;
	}

	T **operator&()
	{
		return &m_ref->m_stu;
	}

	T &operator*()
	{
		return *m_ref->m_stu;
	}

    //重载类型转换运算符，如果需要T*的地方你可以传递一个类对象过去
	operator T *()
	{
		return m_ref->m_stu;
	}

	void reset()
	{
		m_ref->release();
	}

	void reset(T *stu)
	{
		m_ref->release();
		m_ref = new CRefCount<T>(stu);
	}

	int use_count()
	{
		return m_ref->m_count;
	}

	~CSmartPtr()
	{
		if (m_ref != nullptr)
		{

			cout << "析构---引用计数 =" << use_count() << endl;
			m_ref->release();
		}
	}

private:
	CRefCount<T> *m_ref = nullptr;
};


class student
{
public:
	int show(void)
	{
		cout << "测试" << endl;
		return 0;
	}
};

void fun()
{
	CSmartPtr<student> s_ptr1(new student);
	CSmartPtr<student> s_ptr2 = s_ptr1;
	cout << "sp1引用计数 =" << s_ptr1.use_count() << endl;
	//s_ptr2.reset();
	cout << "sp2引用计数 =" << s_ptr2.use_count() << endl;
}

int main(int argc, char *argv[])
{
	fun();

	return 0;
}