智能指针的实现（构造，析构，赋值，移动，析构）与测试

智能指针代码：

//  引用计数器类  用于存储指向同一对象的指针数
template<typename T>
class Counter
{
private:
	//  数据成员
	T* ptr;    //  对象指针
	int cnt;   //  引用计数器
	//  友元类声明
	template<typename T>
	friend class SmartPtr;
	//  成员函数
	//  构造函数
	Counter(T* p)   //  p为指向动态分配对象的指针
	{
		ptr = p;
		cnt = 1;
	}
	//  析构函数
	~Counter()
	{
		delete ptr;
	}
};

//  智能指针类  
template<typename T>
class SmartPtr
{
private:
	//  数据成员
	T* ptr;
	Counter<T>* ptr_cnt;

public:
	//  普通构造函数  初始化计数类
	SmartPtr(T* p) : ptr(p), ptr_cnt(new Counter<T>(p))
	{
	}
	//  拷贝构造函数
	SmartPtr(const SmartPtr& other) : ptr(other.ptr), ptr_cnt(other.ptr_cnt)
	{
		ptr_cnt->cnt++;
	}
	//  移动构造函数
	SmartPtr(SmartPtr&& other) : ptr(std::move(other.ptr)), ptr_cnt(std::move(other.ptr_cnt))
	{
		other.ptr_cnt = nullptr;
	}

	//  赋值重载
	SmartPtr& operator=(const SmartPtr& rhs)
	{
		if (ptr_cnt != rhs.ptr_cnt)
		{
			if (ptr_cnt != nullptr)
			{
				ptr_cnt->cnt--;
				if (ptr_cnt->cnt == 0)
					delete ptr_cnt;
			}
			ptr = rhs.ptr;
			ptr_cnt = rhs.ptr_cnt;
			rhs.ptr_cnt->cnt++;

		}
		return *this;
	}

	// 移动赋值重载	
	SmartPtr& operator=(SmartPtr && rhs)
	{
		if (ptr_cnt != rhs.ptr_cnt)
		{
			std::swap(this, rhs);
		}
		return *this;
	}

	//  析构函数
	~SmartPtr()
	{
		if (ptr_cnt != nullptr)
		{
			ptr_cnt->cnt--;
			if (ptr_cnt->cnt == 0)
				delete ptr_cnt;
		}
	}

	T& operator*()     const { return *(ptr); }
	T* operator&()     const { return ptr; }
	size_t use_count() const { return ptr_cnt->cnt; }
	bool unique()      const { return (ptr_cnt->cnt == 1); }
	T* get()           const { return ptr; }
};

测试代码：

class test
{
public:
	int n;
	test(int i) :n(i)
	{
		std::cout << "c " << n << std::endl;
	}
	~test()
	{
		std::cout << "d " << n << std::endl;
	}
};

int main(int argc, char** argv) {
	SmartPtr<test> p1 = new test(1);//构造
	std::cout << p1.use_count() << std::endl; //1?
	SmartPtr<test> p2 = p1;//复制构造
	std::cout << p1.use_count() << std::endl;//2?
	std::cout << p1.get()->n << p2.get()->n << std::endl;//11?
	SmartPtr<test> p3(std::move(p2));//移动构造
	std::cout << p1.use_count() << std::endl;//2？
	SmartPtr<test> p4 = new test(2);
	p3 = p4;//赋值
	std::cout << p4.use_count() << p1.use_count() << std::endl;//21?

	return 0;
}

测试结果：