Skip to content

手写三种智能指针 ​

cpp
#include<atomic>
#include<utility>
/////////////////////////////////////////
// unique_ptr
////////////////////////////////////////

template<typename T>
class unique_ptr
{
private:
    T* ptr_;

public:
    explicit unique_ptr(T* p = nullptr) noexcept : ptr_(p){}
    ~unique_ptr() noexcept
    {
        if(ptr_) delete ptr_;
    }
    // 移动构造/移动赋值/swap 必须标:vector 扩容走 move_if_noexcept,没标 noexcept 又有拷贝构造可用时,会退化成拷贝,白丢性能
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
    unique_ptr(unique_ptr&& u) noexcept : ptr_(u.ptr_) {u.ptr_ = nullptr; }
    unique_ptr& operator=(unique_ptr&& u) noexcept
    {
        if(this!=&u) reset(u.release());
        return *this;
    }

    T* release() noexcept
    {
        T* p = ptr_;
        ptr_ = nullptr;
        return p;
    }

    void reset(T* p = nullptr) noexcept
    {
        T* old = ptr_;
        ptr_ = p;
        if(old) delete old;   // 删的是换下来的旧指针,这个顺序反了就扛不住 p.reset(p.get())
    }

    T* get() const noexcept{ return ptr_; }
    // 可以通过解引用拿到对象
    T& operator*() const noexcept {return *ptr_; }
    // 交出裸指针,剩下交给编译器
    T* operator->() const noexcept {return ptr_; }
    // 支持 if(p) / if(!p);explicit 是为了防止它被隐式转成整数参与运算
    explicit operator bool() const noexcept { return ptr_ != nullptr; }
};

////////////////////////////////////////////////
// shared_ptr
///////////////////////////////////////////////
struct ControlBlock
{
    std::atomic<int>use_count;
    std::atomic<int>weak_count;
    // weak_count 从 1 开始:这 1 是"强引用侧"的内嵌弱引用(libstdc++ 的做法),
    // 保证对象先死、控制块后死;将来实现 weak_ptr 时它才派上用场
    ControlBlock():use_count(1),weak_count(1){}
};

template<typename T> class weak_ptr;   // 前置声明,下面 shared_ptr 要把它设成友元

template<typename T>
class shared_ptr
{
    // weak_ptr 要读 cb_,还要用下面那个"接管"构造,所以必须开友元
    friend class weak_ptr<T>;

private:
    T* ptr_ = nullptr;
    ControlBlock* cb_ = nullptr;

    // 供 weak_ptr::lock 用:引用计数已经在 lock 里 CAS 加过了,这里只接管,不再加
    shared_ptr(T* p, ControlBlock* cb) noexcept : ptr_(p),cb_(cb){}

public:
    shared_ptr() noexcept = default;
    // 这里必须 explicit:否则 shared_ptr<Foo> sp = new Foo; 会隐式发生所有权转移
    explicit shared_ptr(T* p):ptr_(p),cb_(new ControlBlock()){}
    ~shared_ptr()
    {
        if(!cb_) return;
        if(cb_->use_count.fetch_sub(1,std::memory_order_acq_rel)==1)
        {
            delete ptr_;
            // 最后一个强引用消失,才归还内嵌的那一份弱引用
            if(cb_->weak_count.fetch_sub(1,std::memory_order_acq_rel)==1)
            {
                delete cb_;
            }
        }
    }

    // 拷贝构造标 noexcept 是对的:引用计数只做原子加,不会抛
    shared_ptr(const shared_ptr& o) noexcept : ptr_(o.ptr_),cb_(o.cb_)
    {
        if(cb_) cb_->use_count.fetch_add(1,std::memory_order_relaxed);
    }
    shared_ptr(shared_ptr&& o) noexcept : ptr_(o.ptr_),cb_(o.cb_)
    {
        o.ptr_ = nullptr;
        o.cb_ = nullptr;
    }
    // 赋值运算符不能加 explicit(explicit 只能用在构造函数和转换函数上)
    shared_ptr& operator=(const shared_ptr& o)
    {
        if(this!=&o)
        {
            shared_ptr tmp(o);
            swap(tmp);
        }
        return *this;
    }
    shared_ptr& operator=(shared_ptr&& o)
    {
        if(this!=&o)
        {
            shared_ptr tmp(std::move(o));
            swap(tmp);
        }
        return *this;
    }
    void swap(shared_ptr& o) noexcept
    {
        std::swap(ptr_,o.ptr_);
        std::swap(cb_,o.cb_);
    }

    int use_count() const noexcept
    {
        return cb_?cb_->use_count.load(std::memory_order_relaxed):0;
    }
    T* get() const noexcept { return ptr_; }
    T& operator*() const noexcept {return *ptr_;}
    T* operator->() const noexcept {return ptr_;}
    // 支持 if(p) / if(!p);explicit 是为了防止它被隐式转成整数参与运算
    explicit operator bool() const noexcept { return ptr_ != nullptr; }
};

////////////////////////////////////////////
// weak_ptr
///////////////////////////////////////////
template<typename T>
class weak_ptr
{
private:
    T* ptr_ = nullptr;
    ControlBlock* cb_ = nullptr;

public:
    weak_ptr() noexcept = default;

    // 从 shared_ptr 构造,不是 explicit:weak_ptr 本来就是 shared_ptr 的弱引用
    weak_ptr(const shared_ptr<T>& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
    {
        if(cb_) cb_->weak_count.fetch_add(1,std::memory_order_relaxed);
    }

    // 拷贝构造必须自己写!否则编译器隐式生成的版本只浅拷贝指针,不会加计数
    weak_ptr(const weak_ptr& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
    {
        if(cb_) cb_->weak_count.fetch_add(1,std::memory_order_relaxed);
    }
    weak_ptr(weak_ptr&& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
    {
        o.ptr_ = nullptr;
        o.cb_ = nullptr;
    }
    weak_ptr& operator=(const weak_ptr& o) noexcept
    {
        if(this!=&o)
        {
            weak_ptr tmp(o);   // 先加后减,自赋值也安全
            swap(tmp);
        }
        return *this;
    }
    weak_ptr& operator=(weak_ptr&& o) noexcept
    {
        if(this!=&o)
        {
            weak_ptr tmp(std::move(o));
            swap(tmp);
        }
        return *this;
    }
    ~weak_ptr()
    {
        // 关键:最后一个 weak_ptr 消失,才真正释放控制块。
        // 少了这一步,只要 weak_ptr 比 shared_ptr 活得久,控制块就永久泄漏
        if(cb_ && cb_->weak_count.fetch_sub(1,std::memory_order_acq_rel)==1)
        {
            delete cb_;
        }
    }

    void swap(weak_ptr& o) noexcept
    {
        std::swap(ptr_,o.ptr_);
        std::swap(cb_,o.cb_);
    }

    bool expired() const noexcept
    {
        return !cb_||cb_->use_count.load(std::memory_order_relaxed)==0;
    }
    shared_ptr<T> lock() const noexcept
    {
        if(!cb_) return shared_ptr<T>();   // 空的 weak_ptr,不能直接解引用 cb_

        int n = cb_->use_count.load(std::memory_order_relaxed);
        while(n>0)
        {
            // CAS 失败时 n 会被自动更新成当前值(含伪失败),所以这个循环是安全的
            if(cb_->use_count.compare_exchange_weak(n,n+1,
                    std::memory_order_acq_rel,std::memory_order_relaxed))
            {
                // 计数已经加过了,用接管构造,不能再走普通构造多加一次
                return shared_ptr<T>(ptr_,cb_);
            }
        }
        return shared_ptr<T>();
    }
};