C++简单实现shared_ptr的代码

SharedPtr()noexcept = default // 默认构造
explicit SharedPtr(T* ptr) noexcept // 参数构造
SharedPtr(const SharedPtr& ptr)noexcept // 拷贝构造
SharedPtr(SharedPtr&& ptr)noexcept // 移动构造
~SharedPtr() noexcept // 析构函数

SharedPtr& operator=(const SharedPtr& rhs)noexcept  // 拷贝赋值运算符重载
SharedPtr& operator=(SharedPtr&& rhs)noexcept  // 移动赋值运算符重载
T& operator->() const noexcept // 指针运算符重载
T& operator*() const noexcept // 解引用运算符重载

T* get() const noexcept // 获取原始指针对象
int use_count() const noexcept // 获取引用计数
void reset()noexcept // 重置指针
bool unique() noexcept // 判断是否只有一个使用者
void swap() noexcept // 交换对象内容

#include
using namespace std;
 
// 引用计数类
class RefCount {
private:
	int count{1};
public:
	int use_count() const noexcept { return count; }
	void dec_count()noexcept { --count; }
	void inc_count()noexcept { ++count; }
};
 
// shared_ptr类模板
template
class SharedPtr {
private:
	T* origin_ptr{ nullptr }; // 原始指针
	RefCount* refCount{ nullptr }; // 引用计数
public:
	SharedPtr()noexcept = default; // 默认构造
	SharedPtr(nullptr_t)noexcept :SharedPtr() {} // 空指针构造
	explicit SharedPtr(T* ptr)noexcept :origin_ptr(ptr), refCount(nullptr){ // 用原始指针作为参数构造
		if (origin_ptr != nullptr) refCount = new RefCount();
	}
	SharedPtr(const SharedPtr& ptr)noexcept :origin_ptr(ptr.origin_ptr), refCount(ptr.refCount) { // 拷贝构造
		if(origin_ptr != nullptr) refCount->inc_count();
	}
	SharedPtr(SharedPtr&& ptr)noexcept :origin_ptr(ptr.origin_ptr), refCount(ptr.refCount) { // 移动构造
		ptr.origin_ptr = nullptr;
		ptr.refCount = nullptr;
	}
	~SharedPtr()noexcept { // 析构函数
		if (origin_ptr != nullptr && refCount->use_count() == 0) {
			delete origin_ptr;
			delete refCount;
			origin_ptr = nullptr;
			refCount = nullptr;
		}
	}
	SharedPtr& operator=(const SharedPtr& rhs)noexcept { // 拷贝赋值运算符重载
		SharedPtr(rhs).swap(*this);
		return *this;
	}
	SharedPtr& operator=(SharedPtr&& rhs)noexcept { // 移动赋值运算符重载
		SharedPtr(move(rhs)).swap(*this);
		return *this;
	}
	T& operator->() const noexcept{ // 指针运算符重载
		return origin_ptr;
	}
	T& operator*() const noexcept { // 解引用运算符重载
		return *origin_ptr;
	}
 
public: // 以下是提供的接口函数
	T* get()const noexcept { // get()函数获取原始指针对象
		return origin_ptr;
	}
	int use_count() const noexcept { // use_count()函数获取引用计数
		return origin_ptr == nullptr ? 0 : refCount->use_count();
	}
	void reset()noexcept { // reset()重置指针
		SharedPtr().swap(*this);
	}
	void reset(nullptr_t) noexcept {
		reset();
	}
	void reset(T* ptr)noexcept {
		SharedPtr(ptr).swap(*this);
	}
	bool unique()noexcept { // unique() 查看是否资源独有
		return refCount == nullptr ? false : (refCount->use_count() == 1);
	}
	void swap(SharedPtr& rhs) noexcept{ // swap()交换对象内容
		std::swap(origin_ptr, rhs.origin_ptr); // 这里必须显示指定是std命名空间！
		std::swap(refCount, rhs.refCount);
	}
};
int main() {
	int* a = new int(2);
	SharedPtrp(a); //测试构造函数
	cout << p.use_count() << endl;
	cout << *p << endl;
	SharedPtrq(p); //测试拷贝构造
	cout << p.use_count() << endl;
	cout << q.use_count() << endl;
	SharedPtrn = p; //测试赋值运算符
	cout << p.use_count() << endl;
	cout << n.use_count() << endl;
	SharedPtrm = move(p); //测试右值引用赋值运算符
	cout << q.use_count() << endl;
	// cout << p.get_count() << endl;
	q.reset();
	cout << q.get() << endl;
	return 0;
}

	（构造函数）构造shared_ptr（公共成员函数）
	（析构函数）销毁shared_ptr（公共成员函数）
	operator=	shared_ptr赋值（公共成员函数）
	swap	交换内容（公共成员函数）
	reset	重置指针（公共成员函数）
	get	获取指针（公共成员函数）
	operator*	取消引用对象（公共成员函数）
	operator->	取消引用对象成员（公共成员函数）
	operator[]  (C++17)提供到被存储数组的带下标访问(公开成员函数)
	use_count	返回计数（公共成员函数）
	unique(C++20前)	检查是否唯一（公共成员函数）
	operator bool	检查是否不为空（公共成员函数）
	owner_before	基于所有者的共享指针排序（公共成员函数模板）

非成员函数
	swap	交换shared_ptr对象的内容（函数模板）
	relational operators	关系运算符 ==， ！=， <， <=， >， >= （函数模板 ）
	ostream operator<<	将存储的指针的值输出到输出流（函数模板）

具体功能：
	make_shared，make_shared_for_overwrite(C++20)	创建管理一个新对象的共享指针（函数模板）
	allocate_shared，allocate_shared_for_overwrite(C++20)	创建管理一个用分配器分配的新对象的共享指针（函数模板）
	static_pointer_cast，dynamic_pointer_cast，const_pointer_cast，reinterpret_pointer_cast    (C++17)应用 static_cast、dynamic_cast、const_cast 或 reinterpret_cast 到被存储指针(函数模板)
	get_deleter	返回指定类型中的删除器，若其拥有（函数模板）

#include 
#include 

class ref_count
{
public:
    int use_count() const noexcept { return count_; }
    void inc_ref() noexcept { ++count_; }
    int dec_ref() noexcept { return --count_; }

private:
    int count_{1};
};

template 
class Shared_ptr
{
public:
    constexpr Shared_ptr() noexcept = default;
    constexpr Shared_ptr(nullptr_t) noexcept : Shared_ptr() {}
    explicit Shared_ptr(T *ptr) : ptr_{ptr}
    {
        if (ptr_ != nullptr)
        {
            rep_ = new ref_count{};
        }
    }
    Shared_ptr(const Shared_ptr &rhs) noexcept : ptr_{rhs.ptr_}, rep_{rhs.rep_}
    {
        if (ptr_ != nullptr)
        {
            rep_->inc_ref();
        }
    }
    Shared_ptr(Shared_ptr &&rhs) noexcept : ptr_{rhs.ptr_}, rep_{rhs.rep_}
    {
        rhs.ptr_ = nullptr;
        rhs.rep_ = nullptr;
    }
    ~Shared_ptr() noexcept
    {
        if (rep_ != nullptr && rep_->dec_ref() == 0)
        {
            delete ptr_;
            delete rep_;
        }
    }

    Shared_ptr &operator=(const Shared_ptr &rhs)
    {
        Shared_ptr{rhs}.swap(*this);
        return *this;
    }
    Shared_ptr &operator=(Shared_ptr &&rhs)
    {
        Shared_ptr{std::move(rhs)}.swap(*this);
        return *this;
    }
    void reset() noexcept
    {
        Shared_ptr{}.swap(*this);
    }
    void reset(nullptr_t) noexcept
    {
        reset();
    }
    void reset(T *ptr)
    {
        Shared_ptr{ptr}.swap(*this);
    }

    void swap(Shared_ptr &rhs) noexcept
    {
        std::swap(ptr_, rhs.ptr_);
        std::swap(rep_, rhs.rep_);
    }
    T *get() const noexcept
    {
        return ptr_;
    }

    long use_count() const noexcept
    {
        return rep_ == nullptr ? 0 : rep_->use_count();
    }
    bool unique() const noexcept
    {
        return rep_->use_count() == 1;
    }

    T &operator*() const noexcept
    {
        return *ptr_;
    }
    T &operator->() const noexcept
    {
        return ptr_;
    }

    explicit operator bool() const noexcept
    {
        return static_cast(ptr_);
    }

private:
    T *ptr_{nullptr};
    ref_count *rep_{nullptr};
};

template 
auto make_Shared(Args &&...args)
{
    return Shared_ptr{new T(std::forward(args)...)};
}