c++智能指针shared_ptr、weak_ptr、unique_ptr

使用c++智能指针需要包含头文件<memory>，对于SGI版本的STL, shared_ptr、weak_ptr实现在<bits/shared_ptr.h>中，unique_ptr实现在<bits/unique_ptr.h>中

 

1、 shared_ptr

　　作用：通过应用计数实现自动释放指针，用户不用再去关心资源的释放回收

　　注意点：

　　　　a. 指针释放默认使用delete，所以对于不是new的指针，需要在构造函数第二个参数传入释放器，例如对于数组指针

std::shared_ptr<char> shr_p(p, [](char* p) { delete[] p; });

　　　　b. 不要对同一个内置指针通过构造函数或 reset函数生成多个智能指针对象

 

2、 weak_ptr

　　作用：是辅助观察shared_ptr，weak_ptr不会影响指针的释放，它的入参只能是shared_ptr或者weak_ptr,在shared_ptr对象全部销毁后，可以用过weak_ptr查看引用　　                  计数，这样避免了shared_ptr循环应用问题

 

3、 unique_ptr

　　作用：高效的唯一指针，析构后会自动释放资源

　　注意点：

　　　　a. 它和auto_ptr的区别是，unique_ptr在被拷贝时自身资源也会被swap走，这样就规避了不易发现的浅拷贝导致指针多次释放的问题

　　　　b. 同shared_ptr一样，unique_ptr也是默认使用delete释放资源，所以非new的指针也需要传入个释放器，释放器是在模板入参里传入的

4、shared_ptr和weak_ptr的代码实现及验证

　　参考STL源码做一个简单的实现

#include <atomic>
#include <functional>

template<typename Ptr>
class Sp_counted_base
{
public:
    Sp_counted_base(Ptr p)
        : m_ptr(p), m_use_count(1), m_weak_count(1){}
    Sp_counted_base(Ptr p, std::function<void(Ptr)> func)
        : m_ptr(p), m_use_count(1), m_weak_count(1) 
    {
        m_func = func;
    }
    // 禁止拷贝
    Sp_counted_base(Sp_counted_base const&) = delete;
    Sp_counted_base& operator=(Sp_counted_base const&) = delete;
    
    virtual ~Sp_counted_base() noexcept { }

    // 当引用计数m_use_count为0的时候就释放资源，通过*this
    virtual void m_dispose() noexcept
    {
        std::cout<< "m_dispose"<<std::endl;
        if (m_func)
        {
            m_func(m_ptr);
        }
        else
        {
            delete m_ptr;  // 默认使用deleter释放资源
        }
    }

    // 当引用计数m_weak_count为0的时候就释放资源.
    virtual void m_destroy() noexcept
    {
        delete this;
    }

    //引用计数递增
    void m_add_ref_copy()
    {
        m_use_count++;
    }

    // 引用计数递减
    void m_release() noexcept
    {
        m_use_count--;
        if (m_use_count.load() == 0)
        {
            m_dispose(); //释放指针数据
            m_weak_count--; // shared_ptr销毁时，weak_ptr引用计数减一
            if (m_weak_count.load() == 0)
            {
                m_destroy();
            }
        }
    }

    // weak_ptr引用计数递增
    void m_weak_add_ref() noexcept
    {
        m_weak_count++;
    }

    // weak_ptr引用计数递增
    void m_weak_release() noexcept
    {
        m_weak_count--;
        if (m_weak_count.load() == 0)
        {
            m_destroy(); // 这里只销毁weak_ptr对象，并不会释放资源
        }
    }
    // 获取引用计数
    long m_get_use_count() const noexcept
    {
        return m_use_count.load();
    }

private:
    Ptr                    m_ptr;            // 指针数据
    std::atomic<int>    m_use_count;    // #shared
    std::atomic<int>    m_weak_count;   // #weak + (#shared != 0)
    std::function<void(Ptr)>      m_func{}; // 这里用一个回调函数来实现删除器
};

template<typename Ptr>
class shared_count
{
public:
    constexpr shared_count() noexcept : m_pi(0) { }
    explicit shared_count(Ptr p) : m_pi(0)
    {
        m_pi = new Sp_counted_base<Ptr>(p);
    }
    // 带释放器入参的构造函数
    explicit shared_count(Ptr p, std::function<void(Ptr)> func) : m_pi(0)
    {
        m_pi = new Sp_counted_base<Ptr>(p, func);
    }
    
    ~shared_count() noexcept
    {
        if (m_pi != nullptr)
        {
            m_pi->m_release();
        }
    }

    shared_count(const shared_count& r) noexcept
        : m_pi(r.m_pi)
    {
        if (m_pi != 0)
        {
            m_pi->m_add_ref_copy();
        }
    }

    shared_count& operator=(const shared_count& r) noexcept
    {
        Sp_counted_base<Ptr>* tmp = r.m_pi;
        if (tmp != m_pi)
        {
            if (tmp != 0)
            {
                tmp->m_add_ref_copy(); // 被拷贝的对象引用计数++
            }
            if (m_pi != 0)
            {
                m_pi->m_release(); // 自身引用计数--
            }
            m_pi = tmp;
        }
        return *this;
    }

    void m_swap(shared_count& r) noexcept
    {
        Sp_counted_base<Ptr>* tmp = r.m_pi;
        r.m_pi = m_pi;
        m_pi = tmp;
    }

    long m_get_use_count() const noexcept
    {
        return m_pi != 0 ? m_pi->m_get_use_count() : 0;
    }

    bool m_unique() const noexcept
    {
        return this->m_get_use_count() == 1;
    }
public:
    Sp_counted_base<Ptr>*  m_pi;
};

// shared_ptr的实现
template<typename Tp>
class My_shared_ptr
{
public:
    constexpr My_shared_ptr() noexcept
        : m_ptr(0), m_refcount() { }
    explicit My_shared_ptr(Tp* p)
        : m_ptr(p), m_refcount(p) {}
    explicit My_shared_ptr(Tp* p, std::function<void(Tp*)> func)
        : m_ptr(p), m_refcount(p,func) {}
    // 拷贝构造都用默认函数，引用计数会++
    My_shared_ptr(const My_shared_ptr&) noexcept = default;
    My_shared_ptr& operator=(const My_shared_ptr&) noexcept = default;
    
    // 移植构造
    My_shared_ptr(My_shared_ptr<Tp>&& r) noexcept
        : m_ptr(r.m_ptr), m_refcount()
    {
        // 用一个空的m_refcount把r的指针交换过来，引用计数不变
        m_refcount.m_swap(r.m_refcount);
        r.m_ptr = 0;
    }
    My_shared_ptr& operator=(My_shared_ptr&& r) noexcept
    {
        // r的应用计数不变， this指向资源的应用计数--
        My_shared_ptr(std::move(r)).swap(*this);
        return *this;
    }
    ~My_shared_ptr() = default;

    void reset() noexcept
    {
        // 空对象交换下this,this就变空了，空对象析构，资源指针引用计数--
        My_shared_ptr().swap(*this);
    }

    void reset(Tp* p) // Tp must be complete.
    {
        // p和this交换资源，新构造的对象析构，this的应用计数--
        My_shared_ptr(p).swap(*this);
    }

    Tp operator*() const noexcept
    {
        return *m_ptr;
    }

    Tp* operator->() const noexcept
    {
        return m_ptr;
    }
    Tp* get() const noexcept
    {
        return m_ptr;
    }
    long use_count() const noexcept
    {
        return m_refcount.m_get_use_count();
    }

    void swap(My_shared_ptr<Tp>& other) noexcept
    {
        std::swap(m_ptr, other.m_ptr);
        m_refcount.m_swap(other.m_refcount);
    }
    Tp*                       m_ptr;         // Contained pointer.
    shared_count<Tp*>    m_refcount;    // Reference counter.

private:
};

template<typename Ptr>
class weak_count
{
public:
    constexpr weak_count() noexcept : m_pi(0) { }

    weak_count(const shared_count<Ptr>& r) noexcept
        : m_pi(r.m_pi)
    {
        if (m_pi != 0)
            m_pi->m_weak_add_ref();
    }
    weak_count(const weak_count& r) noexcept
        : m_pi(r.m_pi)
    {
        if (m_pi != 0)
            m_pi->m_weak_add_ref();
    }
    ~weak_count() noexcept
    {
        if (m_pi != 0)
            m_pi->m_weak_release();
    }

    weak_count& operator=(const shared_count<Ptr>& r) noexcept
    {
        Sp_counted_base<Ptr>* tmp = r.m_pi;
        if (tmp != 0)
            tmp->m_weak_add_ref();
        if (m_pi != 0)
            m_pi->m_weak_release();
        m_pi = tmp;
        return *this;
    }

    weak_count& operator=(const weak_count& r) noexcept
    {
        Sp_counted_base<Ptr>* tmp = r.m_pi;
        if (tmp != 0)
            tmp->m_weak_add_ref();
        if (m_pi != 0)
            m_pi->m_weak_release();
        m_pi = tmp;
        return *this;
    }

    void m_swap(weak_count& r) noexcept
    {
        Sp_counted_base<Ptr>* tmp = r.m_pi;
        r.m_pi = m_pi;
        m_pi = tmp;
    }

    long m_get_use_count() const noexcept
    {
        return m_pi != 0 ? m_pi->m_get_use_count() : 0;
    }
private:
    Sp_counted_base<Ptr>*  m_pi;
};

template<typename Tp>
class My_weak_ptr
{
public:
    constexpr My_weak_ptr() noexcept
        : m_ptr(0), m_refcount()
    { }

    My_weak_ptr(const My_shared_ptr<Tp>& r) noexcept
        : m_ptr(r.m_ptr), m_refcount(r.m_refcount)
    { }

    My_weak_ptr& operator=(const My_shared_ptr<Tp>& r) noexcept
    {
        m_ptr = r.m_ptr;
        m_refcount = r.m_refcount;
        return *this;
    }

    My_weak_ptr& operator=(const My_weak_ptr<Tp>& r) noexcept
    {
        m_ptr = r.m_ptr;
        m_refcount = r.m_refcount;
        return *this;
    }
    long use_count() const noexcept
    {
        return m_refcount.m_get_use_count();
    }

    bool
        expired() const noexcept
    {
        return m_refcount.m_get_use_count() == 0;
    }
private:
    Tp*             m_ptr;                // Contained pointer.
    weak_count<Tp*>  m_refcount;    // Reference counter.
};

main函数

#include <iostream>
#include "My_shared_ptr.h"
struct A
{
    ~A()
    {
        std::cout << "~A" << std::endl;
    }
};
int main()
{
    My_weak_ptr<A> f;
    {
        A* ptr = new A[5];
        My_shared_ptr <A> a(ptr, [](A* p) {delete[] p; });
        f = a;
        std::cout << f.use_count() << std::endl; // 输出1
        My_shared_ptr<A> b = a;
        std::cout << f.use_count() << std::endl; // 输出2
        My_shared_ptr<A> c(a);                     
        std::cout << f.use_count() << std::endl; // 输出3
        My_shared_ptr<A> d(std::move(c));
        std::cout << f.use_count() << std::endl; // 输出3
        My_shared_ptr<A> e = std::move(d);        
        std::cout << f.use_count() << std::endl; // 输出3

    }
    std::cout << f.use_count() << std::endl;// 输出0
    return 0;
}