手动实现智能指针之Shared_ptr《简易版》

学习打卡

简单实现Shared_ptr

template <typename T>
class Smart_ptr
{
public:
	template<typename U>
	friend class Smart_ptr;

	explicit Smart_ptr(T* ptr = nullptr) : m_ptr(ptr) 
	{
		if (m_ptr)
		{
			m_count = new Smart_count();
		}
	}
	~Smart_ptr()
	{
		printf("~smart_ptr(): %p\n", this);
		if (m_ptr && !m_count->reduceCount())
		{
			delete m_ptr;
			delete m_count;
		}
	};
	
	template<typename U>
	Smart_ptr( const Smart_ptr<U>& other_ptr) noexcept
	{
		m_ptr = other_ptr.m_ptr;
		if (m_ptr)
		{
			other_ptr.m_count->addCount();
			m_count = other_ptr.m_count;
		}
	}
	template<typename U>
	Smart_ptr(Smart_ptr<U>&& other_ptr) noexcept
	{
		m_ptr = other_ptr.m_ptr;
		if (m_ptr)
		{
			m_count = other_ptr.m_count;
			other_ptr.m_ptr = nullptr;
		}
	}
	template <typename U>
	Smart_ptr(const Smart_ptr<U>& other_ptr ,T* ptr) noexcept
	{
		m_ptr = m_ptr;
		if (m_ptr)
		{
			other_ptr.m_count->addCount();
			m_count = other_ptr.m_count;
		}
	}
	Smart_ptr& operator = (Smart_ptr ptr) noexcept
	{
		ptr.swap(*this);
		return *this;
	}
	
	void swap(Smart_ptr& ptr) noexcept
	{
		using::std::swap;
		swap(m_ptr, ptr.m_ptr);
		swap(m_count, ptr.m_count);
	}
		//解引用
	T& operator *()const noexcept { return *m_ptr; }
	//可使用->
	T* operator ->()const noexcept { return m_ptr; }
	//可返回bool
	operator bool()const noexcept { return m_ptr; }
	
	T* get()const noexcept { return m_ptr;}
	
	long use_count()noexcept
	{
		if (m_ptr)
		{
			return m_count->getCount();
		}
		else
		{
			return 0;
		}
	}

private:
	T* m_ptr;
	Smart_count* m_count;
};

template <typename T>
void swap(Smart_ptr<T>& lhs, Smart_ptr<T>& rhs) noexcept
{
	lhs.swap(rhs);
}
template <typename T ,typename U>
Smart_ptr<T> static_pointer_cast(const Smart_ptr<U>& other) noexcept
{
	T* ptr = static_cast<T*>(other.get());
	return Smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
Smart_ptr<T> reinterpret_pointer_cast(const Smart_ptr<U>& other) noexcept
{
	T* ptr = reinterpret_cast<T*>(other.get());
	return Smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
Smart_ptr<T> const_pointer_cast(const Smart_ptr<U>& other) noexcept
{
	T* ptr = const_cast<T*>(other.get());
	return Smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
Smart_ptr<T> dynamic_pointer_cast(const Smart_ptr<U>& other) noexcept
{
	T* ptr = dynamic_cast<T*>(other.get());
	return Smart_ptr<T>(other, ptr);
}