精华内容
下载资源
问答
  • C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法,记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1,当过期时引用计数减一。只有引用计数为0时,智能...
  • 正如boost文档所宣称的,boost为shared_ptr提供了与内置类型同级别的线程安全性。这包括:1. 同一个shared_ptr对象可以被多线程同时读取。2. 不同的shared_ptr对象可以被多线程同时修改成
  • 主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用,感兴趣的小伙伴们可以参考一下
  • 主要介绍了 C++11 智能指针之shared_ptr的相关知识,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • shared_ptr在boost中地位相当重要,其行为接近原始指针,但又比指针更加安全,甚至还能提供基本的线程安全保证。它基本上解决了在使用c++开发过程中不可避免的使用指针而遇到的许多问题,常见的毫无疑问是内存泄漏和...
  • 我在《Linux 多线程服务端编程:使用 muduo C++ 网络库》第 1.9 节“再论 shared_ptr 的线程安全”中写道: (shared_ptr)的引用计数本身是安全且无锁的,但对象的读写则不是,因为 shared_ptr 有两个数据成员,...
  • 主要介绍了C++11 std::shared_ptr总结与使用,本文通过示例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • shared_ptr是一种智能指针(smart pointer)。shared_ptr的作用有如同指针,但会记录有多少个shared_ptrs共同指向一个对象。 这便是所谓的引用计数(reference counting)。一旦最后一个这样的指针被销毁,也就是...
  • C++智能指针shared_ptr分析 概要: shared_ptr是c++智能指针中适用场景多,功能实现较多的智能指针。它采取引用计数的方法来实现释放指针所指向的资源。下面是我代码实现的基本功能。 实例代码: template class ...
  • C++ 智能指针(shared_ptr/weak_ptr)源码 源码位置:gcc-6.1.0\gcc-6.1.0\libstdc++-v3\include\tr1 这里只单列shared_ptr.h文件用于分析
  • shared_ptr的基本用法 (一)与unique_ptr的比较 比较 shared_ptr unique_ptr 备注 初始化 ①shared_ptr<T> sp; sp.reset(new T()); ...

    一. shared_ptr的基本用法

    (一)与unique_ptr的比较

    比较

    shared_ptr

    unique_ptr

    备注

    初始化

    ①shared_ptr<T> sp;

      sp.reset(new T());

    ②shared_ptr<T> sp(new T());

    ③shared_ptr<T> sp1 = sp; //拷贝构造

    ④auto sp = make_shared<int>(10);

    ①unique_ptr<T> up;

      up.reset(new T());

    ②unique_ptr<T> up(new T());

    ③unique_ptr<T> up1 = std::move(up);//移动构造

    ④auto up = make_unique<int>(10);

    两者的构造函数将声明为explicit,即不允许隐式类型转换,如shared_ptr<int> sp = new int(10);

    条件判断

    如,if(sp){…}

    如,if(up){…}

    两都均重载operator bool()

    解引用

    *sp

    *up

    解引用,获得它所指向的对象

    ->mem

    sp->mem

    up->mem

    重载->运算符

    get()

    sp.get()

    up.get()

    返回智能指针中保存的裸指针,要小心使用。

    p.swap(q)

    sp.swap(q);

    up.swap(q);

    交换p和q指针

    独有操作

    ①shared_ptr<T> p(q);//拷贝构造

    ②p = q;//赋值

    ③p.unique();若p.use_count()为1,返回true,否则返回false。

    ④p.use_count()//返回强引用计数

    ①up=nullptr;释放up指向的对象,并将up置空。

    ②up.release();//up放弃对指针的控制权,返回裸指针,并将up置空

    ③up.reset();释放up指向的对象。

      up.reset(q);其中q为裸指针。令up指向q所指对象。

      up.reset(nullptr);置空

    注意:

    ①unique_ptr不可拷贝和赋值,但可以被移动

    ②release会切断unique_ptr和它原来管理的对象间的联系。通常用来初始化另一个智能指针

    (二)指定删除器

      1. shared_ptr<T> sp1(q, deleter1);与unique_ptr不同,删除器不是shared_ptr类型的组成部分。假设,shared_ptr<T> sp2(q,deleter2),尽管sp1和sp2有着不同的删除器,但两者的类型是一致的,都可以被放入vector<shared_ptr<T>>类型的同一容器里。

      2. 与std::unique_ptr不同,自定义删除器不会改变std::shared_ptr的大小。其始终是祼指针大小的两倍

      3. 当使用shared_ptr管理动态数组时,需要指定删除器。因为默认删除器不支持数组对象。如shared_ptr<int> sp(new int[10], std::default_delete<int[]>);

      4. 删除器可以是普通函数、函数对象和lambda表达式等。默认的删除器为std::default_delete,其内部是通过delete来实现功能的。

    二. 剖析std::shared_ptr

    (一)std::shared_ptr的内存模型

      1. shared_ptr包含了一个指向对象的指针和一个指向控制块的指针。每一个由std::shared_ptr管理的对象都有一个控制块,它除了包含引用计数之外,还包含了自定义删除器的副本和分配器的副本以及其他附加数据

      2. 控制块的创建规则:

      (1)std::make_shared总是创建一个控制块

      (2)从具备所有权的指针出发构造一个std::shared_ptr时,会创建一个控制块。(如std::unique_ptr转为shared_ptr时会创建控制块,因为unique_ptr本身不使用控制块,同时unique_ptr置空)

      (3)当std::shared_ptr构造函数使用裸指针作为实参时,会创建一个控制块。这意味从同一个裸指针出发来构造不止一个std::shared_ptr时会创建多重的控制块,也意味着对象会被析构多次。如果想从一个己经拥有控制块的对象出发创建一个std::shared_ptr,可以传递一个shared_ptr或weak_ptr而非裸指针作为构造函数的实参,这样则不会创建新的控制块。

    【经验】

      ①尽可能避免将裸指针传递给一个std::shared_ptr的构造函数,常用的替代手法是使用std::make_shared。

      ②如果必须将一个裸指针传递给shared_ptr的构造函数,就直接传递new运算符的结果,而非传递一个裸指针变量。如shared_ptr<Widget> spw (new Widget, logginDel);

      ③不要将this指针返回给shared_ptr。当希望将this指针托管给shared_ptr时,类需要继承自std::enable_shared_from_this,并且从shared_from_this()中获得shared_ptr指针。(具体见《enable_shared_from_this》部分的分析)

      3. 引用计数(强引用计数)

      (1)shared_ptr的构造函数会使该引用计数递增,而析构函数会使该计数递减。但移动构造时表示从一个己有的shared_ptr移动构造到一个新的shared_ptr。这意味着一旦新的shared_ptr产生后,原有的shared_ptr会被置空,其结果是引用计数没有变化。

      (2)复制赋值同时执行两种操作(如sp1 和sp2是指向不同对象的shared_ptr,则sp1 = sp2时,将修改sp1使得其指向sp2所指的对象。而最初sp1所指向的对象的引用计数递减,同时sp2所指向的对象引用计数递增)

      (3)reset函数,如果不带参数时,则引用计数减1。如果不带参数时,如sp.reset(p)则sp原来指向的对象引用计数减1,同时sp指向新的对象(p)

      (4)如果实施一次递减后最后的引用计数变成0,即不再有shared_ptr指向该对象,则会被shared_ptr析构掉

      (5)引用计数的递增和递减是原子操作,即允许不同线程并发改变引用计数。

    【编程实验】shared_ptr的陷阱分析

    #include <iostream>
    #include <vector>
    #include <memory> // for smart pointer
    
    using namespace std;
    
    class Widget{};
    
    void func(shared_ptr<Widget> sp){}
    
    int funcException() { /*throw 1;*/ return 0; } //假设该函数会抛出异常
    
    void demo(shared_ptr<int> sp, int f){}
    
    int main()
    {
        //1. 陷阱:用同一裸指针创建多个shared_ptr
        //1.1 错误做法
        auto pw = new Widget;
        std::shared_ptr<Widget> spw1(pw); //强引用计数为1,为pw创建一个控制块
        //std::shared_ptr<Widget> spw2(pw); //强引用计数为1,为pw创建另一个新的控制块,会导致多次析构
    
        auto sp = new Widget;
        func(shared_ptr<Widget>(sp)); //慎用裸指针,sp将在func结束后被释放!
    
        //1.2 正确做法
        std::shared_ptr<Widget> spw3(spw1); //ok,pw的强引用计数为2。使用与spw1同一个控制块。
        std::shared_ptr<Widget> spw4(new Widget); //将new的结果直接传递给shared_ptr
        std::shared_ptr<Widget> spw5 = std::make_shared<Widget>(); //强烈推荐的做法!
        
        //2. 陷阱:在函数实参中创建shared_ptr
        //2.1 shared_ptr与异常安全问题
        //由于参数的计算顺序因编译器和调用约定而异。假定按如下顺序计算
        //A.先前new int,然后funcException();
        //B.假设恰好此时funcException产生异常。
        //C.因异常出现shared_ptr还来不及创建,于是int内存泄露
        demo(shared_ptr<int>(new int(100)), funcException());
    
        //2.2 正确做法
        auto p1 = std::make_shared<int>(100);
        demo(p1, funcException());
    
        //3. 陷阱:shared_ptr的循环引用(应避免)(见第22课 weak_ptr)
    
        //4. 删除器
        auto deleter1 = [](Widget* pw) {cout << "deleter1"<< endl; delete pw; };
        auto deleter2 = [](Widget* pw) {cout << "deleter2"<< endl; delete pw; };
    
        std::shared_ptr<Widget> pw1(new Widget, deleter1);
        std::shared_ptr<Widget> pw2(new Widget, deleter2);
    
        std::shared_ptr<Widget> pw3(pw1);
        pw3.reset(new Widget); //deleter恢复为默认的std::default_delete
    
        vector<std::shared_ptr<Widget>> vecs;
        vecs.emplace_back(pw1);
        vecs.emplace_back(pw2); //pw1和pw2虽然有不同的删除器,但类型相同,可以放入同一容器内。
    
        //5. 其它
        //5.1 shared_ptr的大小
        cout << sizeof(spw1) << endl;//8
        cout << sizeof(pw1) << endl; //8
        //5.2 shared_ptr管理动态数组(建议用std::array、std::vector取代)
        std::shared_ptr<int> pArray1(new int[10], [](int* p) {delete[] p; }); //使用delete[]
        std::shared_ptr<int> pArray2(new int[10], std::default_delete<int[]>()); //使用default_delete<int[]>()
        //5.3 常见操作
        cout << pw1.use_count() << endl; //2
    
        if (pw1) //pw1.use_count >= 1 ?
        {
            cout << "pw1.use_count >= 1" << endl;
        }
        else
        {
            cout << "pw1.use_count == 0" << endl;
        }
        //5.4 别名构造
        int* p = new int(10);
    
        std::shared_ptr<int> a(new int(20));
        std::shared_ptr<int> b(a, p);  // alias constructor: co-owns a, points to p。可用于多继承中
                                       // a 和 b拥用相同的控制块,但两者指向的对象不同。由于两者拥用相同的
                                       //的控制块,可认为a和b所指对象具有相同的拥有者,因此10和20两个堆对象
                                       //拥有相同的生命期
        cout << *a << endl; //20
        cout << *b << endl; //10
    
        return 0;
    }

    四. enable_shared_from_this模板的分析

    (一)模板分析(以boost::enable_shared_from_this为例)

    template<class T> class enable_shared_from_this
    {
    protected:
    
        enable_shared_from_this() BOOST_NOEXCEPT
        {
        }
    
        enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
        {
        }
    
        enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
        {
            return *this;
        }
    
        ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
        {
        }
    
    public:
    
        shared_ptr<T> shared_from_this()
        {
            shared_ptr<T> p( weak_this_ );
            BOOST_ASSERT( p.get() == this );
            return p;
        }
    
        shared_ptr<T const> shared_from_this() const
        {
            shared_ptr<T const> p( weak_this_ );
            BOOST_ASSERT( p.get() == this );
            return p;
        }
    
    public: // actually private, but avoids compiler template friendship issues
    
        // Note: invoked automatically by shared_ptr; do not call
        template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
        {
            if( weak_this_.expired() )
            {
                weak_this_ = shared_ptr<T>( *ppx, py );
            }
        }
    
    private:
    
        mutable weak_ptr<T> weak_this_;
    };
    
    boost::enable_shared_from_this

         1. enable_shared_from_this模板类提供两个public属性的shared_from_this成员函数。这两个函数内部会通过weak_this_(weak_ptr类型)成员来创建shared_ptr。

         2. _internal_accept_owner函数不能手动调用,这个函数会被shared_ptr自动调用,该函数是用来初始化唯一的成员变量weak_this_

         3. 根据对象生成顺序,先初始化基类enable_shared_from_this,再初始化派生类对象本身。这时对象己经生成,但weak_this_成员还未被初始化,最后应通过shared_ptr<T> sp(new T())等方式调用shared_ptr构造函数(内部会调用_internal_accept_owner)来初始化weak_this_成员。而如果在调用shared_from_this函数之前weak_this_成员未被初始化,则会通过ASSERT报错提示。

    (二)使用说明

         1. 基类必须为enable_shared_from_this<T>,其中T为派生类的类名。(这种方法叫奇妙递归模板模式)

         2. 通过调用shared_from_this()成员函数获得一个和this指针指向相同对象的shared_ptr。

         3. 从内部实现看,shared_from_this会查询当前对象的控制块,并创建一个指向该控制块的新shared_ptr。这样的设计就要求当前对象己有一个与其关联的控制块。为了实现这一点,就必须有一个己经存在指向当前对象的std::shared_ptr,如果不存在,则通常shared_from_this会抛出异常。

    【编程实验】安全地从this指针创建shared_ptr

    #include <iostream>
    #include <vector>
    #include <memory>
    
    using namespace std;
    
    //1. 从this指针创建shared_ptr
    //1.1 错误的做法
    class Test1
    {
    public:
        //析构函数
        ~Test1() { cout <<"~Test1()" << endl; }
    
        //获取指向当前对象的指针
        std::shared_ptr<Test1> getObject()
        {
            shared_ptr<Test1> pTest(this); //危险! 直接从this指针创建,会为this对象创建新的控制块!
                                           //从而可能导致this所指对象被多次析构
            return pTest;
        }
    };
    
    //1.2 正确的做法
    class Test2 : public std::enable_shared_from_this<Test2> //继承! 注意Test2为基类的模板参数  (递归模板模式)
    {
    public:
        //析构函数
        ~Test2() { cout << "~Test2()" << endl; }
    
        std::shared_ptr<Test2> getObject()
        {
            return shared_from_this(); //调用enable_shared_from_this模板的成员函数,获取this对象的shared_ptr
        }
    };
    
    //2. shared_from_this函数的正确调用
    //2.1 一般做法
    class Test3 : public std::enable_shared_from_this<Test3>
    {
    public:
        //构造函数中不能使用shared_from_this
        Test3()
        {
            //std::shared_ptr<Test3> sp = shared_from_this(); //error,此时基类(enable_shared_from_this<Test3>)
                                                              //虽己构造完,但shared_ptr的构造函数还没被调用,weak_this_指针
                                                              //未被初始化,因此调用shared_from_this会抛出异常
        }
    
        //调用process之前,必须确保shared_ptr的构造函数己被执行(即weak_this_被初始化)
        void process()
        {
            std::shared_ptr<Test3> sp = shared_from_this();
        }
    };
    
    //2.2 改进做法:利用工厂函数来提供shared_ptr
    class Test4 : public std::enable_shared_from_this<Test4>
    {
        Test4() {}  //构造函数设为private
    public:
    
        //提供工厂函数
        template<typename... Ts>
        static std::shared_ptr<Test4> create(Ts&& ... params)
        {
            std::shared_ptr<Test4> ret(new Test4(params...));
            return ret;
        }
    
        void process()
        {
            std::shared_ptr<Test4> sp = shared_from_this();
        }
    };
    
    //3. enable_shared_from_this的应用举例
    class Widget;
    std::vector<std::shared_ptr<Widget>> processWidgets; //记录己被处理过的Widgets
    
    class Widget : public std::enable_shared_from_this<Widget> //需要从这里继承
    {
    public:
        void process()
        {
            //错误做法:直接将this传给shared_ptr<Widget>
            //processWidgets.emplace_back(this); //将处理完的Widget加入链表。
                                                 //error,这种做法本质上是用裸指针来创建shared_ptr,会为this对象创建
                                                 //新的控制块。如果外部new Widget时,也将指针交给shared_ptr管理时,会出现为同
                                                 //一个this对象创建多个控制块,从而造成this对象的多次析构!
    
            //正确做法:(为了确保shared_from_this在shared_ptr构造函数后被调用,可以采用工厂函数的方式来创建Widget,
            //具体见前面的例子)
            processWidgets.emplace_back(shared_from_this()); //将指向当前对象的shared_ptr加入到链表中
        }
    
        ~Widget() { cout <<"~Widget()" << endl; }
    };
    
    int main()
    {
        //1.  从this指针创建shared_ptr
        //1.1 错误做法:对象被多次析构
        {
            //std::shared_ptr<Test1> pt1(new Test1());
            //std::shared_ptr<Test1> pt2 = pt1->getObject();
        }
    
        //1.2 正确做法
        {
            std::shared_ptr<Test2> pt1(new Test2());
            std::shared_ptr<Test2> pt2 = pt1->getObject();
        }
    
        //2. shared_from_this的正确调用
        {
            //2.1 错误方法:
            Test3 t;
            //t.process(); //错误,shared_ptr构造函数没有被执行
    
            Test3* pt = new Test3();
            //pt->process(); //错误,原因同上。
            delete pt;
    
            //正确做法
            std::shared_ptr<Test3> spt(new Test3); //shared_ptr构造被执行,weak_this_被正确初始化
            spt->process(); 
    
            //2.2 工厂方法提供shared_ptr,确保shared_ptr构造函数被执行!
            std::shared_ptr<Test4> spt2 = Test4::create();
            spt2->process();
        }
    
        //3. enable_shared_from_this的应用举例
        {
            std::shared_ptr<Widget> sp(new Widget);
            sp->process();
        }
    
        return 0;
    }

    展开全文
  • 写在最前。。。 0. 前言 所谓智能指针,可以从字面上理解为“智能”的...std::shared_ptr 是一个智能指针,在c++11中发布一直至今。它通过一个pointer保留对象的共享所有权。 1. 源码分析 1.1 头文件 #i..

    写在最前。。。

    请支持原创~~ 

     

     

    0. 前言

    所谓智能指针,可以从字面上理解为“智能”的指针。具体来讲,智能指针和普通指针的用法是相似的,不同之处在于,智能指针可以在适当时机自动释放分配的内存。也就是说,使用智能指针可以很好地避免“忘记释放内存而导致内存泄漏”问题出现。由此可见,C++ 也逐渐开始支持垃圾回收机制了,尽管目前支持程度还有限。

    c++11 中发布了shared_ptrunique_ptrweak_ptr 用以资源的管理,都是定义在memory 这个头文件中。

    • std::shared_ptr 允许多个shared_ptr 实例指向同一个对象,通过计数管理;
    • std::unique_ptr 是独占对象;
    • weak_ptr 是辅助类,是一种弱引用,指向shared_ptr 所管理的对象。

    1. 源码分析

    1.1 头文件

    #include <memory>

    1.2 构造

        constexpr shared_ptr() noexcept;
        template<class Y> explicit shared_ptr(Y* p);
        template<class Y, class D> shared_ptr(Y* p, D d);
        template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
        template <class D> shared_ptr(nullptr_t p, D d);
        template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
        template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
        shared_ptr(const shared_ptr& r) noexcept;
        template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
        shared_ptr(shared_ptr&& r) noexcept;
        template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
        template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
        template<class Y> shared_ptr(auto_ptr<Y>&& r);          // removed in C++17
        template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
        shared_ptr(nullptr_t) : shared_ptr() { }

    构造函数比较多啊,抽一个看看源码。

    1.2.1 shared_ptr 的移动构造函数

    template<class _Tp>
    inline
    shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT
        : __ptr_(__r.__ptr_),
          __cntrl_(__r.__cntrl_)
    {
        __r.__ptr_ = 0;
        __r.__cntrl_ = 0;
    }
    

    大概知道,shared_ptr 中存放一个对象的指针__ptr_ 和用以计数的__cntrl_,这两是shared_ptr 的私有成员变量:

    template<class _Tp>
    class shared_ptr {
        typedef _Tp element_type;
    
    private:
        element_type*      __ptr_;
        __shared_weak_count* __cntrl_;
    
        ...
    }

    另外,移动构造函数因为只是move,所以只是将旧的shared_ptr 转移到新的里。

    1.2.2 shared_ptr 的拷贝构造函数

    template<class _Tp>
    inline
    shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
        : __ptr_(__r.__ptr_),
          __cntrl_(__r.__cntrl_)
    {
        if (__cntrl_)
            __cntrl_->__add_shared();
    }

    与移动构造相同,shared_ptr 实例,需要从参数中获得__ptr_ 和 __cntrl。

    但是,与移动构造函数不同的是,拷贝构造时增加对象计数的。

    下面举例shared_ptr 通常的创建方式:

    std::shared_ptr<int> p1;                  //不传入任何实参
    std::shared_ptr<int> p2(nullptr);         //传入空指针 nullptr
    std::shared_ptr<int> p3(new int(10));     //指定指针为参数
    std::shared_ptr<int> p4(p3);              //或者 std::shared_ptr<int> p4 = p3;
    std::shared_ptr<int> p5(std::move(p4));   //或者 std::shared_ptr<int> p5 = std::move(p4);

    1.3 赋值重载

        shared_ptr& operator=(const shared_ptr& r) noexcept;
        template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
        shared_ptr& operator=(shared_ptr&& r) noexcept;
        template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
        template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17
        template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);

    1.4 修改的接口

        void swap(shared_ptr& r) noexcept;
        void reset() noexcept;
        template<class Y> void reset(Y* p);
        template<class Y, class D> void reset(Y* p, D d);
        template<class Y, class D, class A> void reset(Y* p, D d, A a);

     reset 基本上是对应构造

    1.5 获取

        T* get() const noexcept;
        T& operator*() const noexcept;
        T* operator->() const noexcept;
        long use_count() const noexcept;
        bool unique() const noexcept;
        explicit operator bool() const noexcept;

    对于shared_ptr 的成员函数总结如下:

    成员方法名

    功 能

    operator=()

    重载赋值号,使得同一类型的 shared_ptr 智能指针可以相互赋值。

    operator*()

    重载 * 号,获取当前 shared_ptr 智能指针对象指向的数据。

    operator->()

    重载 -> 号,当智能指针指向的数据类型为自定义的结构体时,通过 -> 运算符可以获取其内部的指定成员。

    swap()

    交换 2 个相同类型 shared_ptr 智能指针的内容。

    reset()

    当函数没有实参时,该函数会使当前 shared_ptr 所指堆内存的引用计数减 1,同时将当前对象重置为一个空指针;当为函数传递一个新申请的堆内存时,则调用该函数的 shared_ptr 对象会获得该存储空间的所有权,并且引用计数的初始值为 1。

    get()

    获得 shared_ptr 对象内部包含的普通指针。

    use_count()

    返回同当前 shared_ptr 对象(包括它)指向相同的所有 shared_ptr 对象的数量。

    unique()

    判断当前 shared_ptr 对象指向的堆内存,是否不再有其它 shared_ptr 对象再指向它。

    operator bool()

    判断当前 shared_ptr 对象是否为空智能指针,如果是空指针,返回 false;反之,返回 true。

    除了上面的成员函数外,C++11 标准还支持同一类型的 shared_ptr 对象,或者 shared_ptr 和 nullptr 之间,进行 ==,!=,,>= 运算。

    注意:

    • shared_ptr用以共享一个对象的所有权,通过计数确认自动回收;
    • shared_ptr 共享的对象所有权,通过存储对象的指针,并通过get() 获取存储的对象的指针;
    • 可能在多个线程中同时用不同的shared_ptr实例,而这些实例可能指向同一个对象。多线程在没有同步的情况访问同一个shared_ptr 实例,并调用其non-const 成员函数时,有可能存在数据竞争。可以使用std::atomic* 函数保护数据竞争;

     2. make_shared

    template<class T, class... Args>
        shared_ptr<T> make_shared(Args&&... args);

    c++11 中针对shared_ptr 还提供了make_shared 这个外部函数,用以创建一个shared_ptr 实例。

    c++ 建议尽可能使用make_shared 创建shared_ptr 实例。

    下面来说明下make_shared 的优缺点。

    2.1 make_shared 优点

    2.1.1 效率高

    shared_ptr 需要维护引用计数的信息:

    • 强引用, 用来记录当前有多少个存活的 shared_ptrs 正持有该对象. 共享的对象会在最后一个强引用离开的时候销毁( 也可能释放).
    • 弱引用, 用来记录当前有多少个正在观察该对象的 weak_ptrs. 当最后一个弱引用离开的时候, 共享的内部信息控制块会被销毁和释放 (共享的对象也会被释放, 如果还没有释放的话).

    如果你通过使用原始的 new 表达式分配对象, 然后传递给 shared_ptr (也就是使用 shared_ptr 的构造函数) 的话, shared_ptr 的实现没有办法选择, 而只能单独的分配控制块:

    auto p = new widget();
    shared_ptr sp1{ p }, sp2{ sp1 };

    如果选择使用 make_shared 的话, 情况就会变成下面这样:

    auto sp1 = make_shared(), sp2{ sp1 };

    内存分配的动作, 可以一次性完成. 这减少了内存分配的次数, 而内存分配是代价很高的操作。

    2.1.2 异常安全

    void F(const std::shared_ptr<Lhs>& lhs, const std::shared_ptr<Rhs>& rhs) { /* ... */ }
    F(std::shared_ptr<Lhs>(new Lhs("foo")),
    std::shared_ptr<Rhs>(new Rhs("bar")));

    C++ 是不保证参数求值顺序, 以及内部表达式的求值顺序的, 所以可能的执行顺序如下:

    • new Lhs(“foo”))
    • new Rhs(“bar”))
    • std::shared_ptr
    • std::shared_ptr

     好了, 现在我们假设在第 2 步的时候, 抛出了一个异常 (比如 out of memory, 总之, Rhs 的构造函数异常了), 那么第一步申请的 Lhs 对象内存泄露了. 这个问题的核心在于, shared_ptr 没有立即获得裸指针

    我们可以用如下方式来修复这个问题.

    auto lhs = std::shared_ptr<Lhs>(new Lhs("foo"));
    auto rhs = std::shared_ptr<Rhs>(new Rhs("bar"));
    F(lhs, rhs);

    当然, 推荐的做法是使用 std::make_shared 来代替:

    F(std::make_shared<Lhs>("foo"), std::make_shared<Rhs>("bar"));

    2.2 make_shared缺点

    • 构造函数是保护或私有时,无法使用 make_shared

    make_shared 虽好, 但也存在一些问题, 比如, 当我想要创建的对象没有公有的构造函数时, make_shared 就无法使用了, 当然我们可以使用一些小技巧来解决这个问题, 比如这里 How do I call ::std::make_shared on a class with only protected or private constructors?

    • 对象的内存可能无法及时回收

    make_shared 只分配一次内存, 这看起来很好. 减少了内存分配的开销. 问题来了, weak_ptr 会保持控制块(强引用, 以及弱引用的信息)的生命周期, 而因此连带着保持了对象分配的内存, 只有最后一个 weak_ptr 离开作用域时, 内存才会被释放. 原本强引用减为 0 时就可以释放的内存, 现在变为了强引用, 若引用都减为 0 时才能释放, 意外的延迟了内存释放的时间. 这对于内存要求高的场景来说, 是一个需要注意的问题. 关于这个问题可以看这里 make_shared, almost a silver bullet

    • 无法像shared_ptr 的构造那样添加一个deleter

    3. 举例

    #include <iostream>
    #include <memory>
    using namespace std;
    
    int main()
    {
        //构建 2 个智能指针
        std::shared_ptr<int> p1(new int(10));
        std::shared_ptr<int> p2(p1);
        //输出 p2 指向的数据
        cout << *p2 << endl;
        p1.reset();//引用计数减 1,p1为空指针
        if (p1) {
            cout << "p1 不为空" << endl;
        }
        else {
            cout << "p1 为空" << endl;
        }
        //以上操作,并不会影响 p2
        cout << *p2 << endl;
        //判断当前和 p2 同指向的智能指针有多少个
        cout << p2.use_count() << endl;
        return 0;
    }

    运行结果:

    10
    p1 为空
    10
    1

    参考:

    why make_shared ? - Bitdewy

    展开全文
  • shared_ptr

    2015-12-16 16:38:22
    shared_ptr boost audio video AVDataPool
  • C++11的智能指针shared_ptr、weak_ptr源码解析

    万次阅读 多人点赞 2021-05-06 22:01:31
    C++智能指针shared_ptr源码解析1、前言2、源码准备3、智能指针概念4、源码解析4.1、shared_ptr解析4.1.1、shared_ptr4.1.2、__shared_ptr4.1.3、__shared_count4.1.4、_Sp_counted_base4.1.5、_Sp_counted_ptr ...

    1、前言

    本文仅对C++智能指针shared_ptr、weak_ptr源码进行解析,需要读者有一定的C++基础并且对智能指针有所了解,本文并不对智能指针的使用方法、使用场景、效率等方面进行阐述分析,这些知识需自行查阅相关书籍去了解

    2、源码准备

    本文是基于gcc-4.9.0的源代码进行分析,shared_ptr和weak_ptr是C++11才加入标准的,所以低版本的gcc源码是没有shared_ptr和weak_ptr的,建议选择4.9.0或更新的版本去学习,不同版本的gcc源码差异应该不小,但是原理和设计思想的一样的,下面给出源码下载地址
    http://ftp.gnu.org/gnu/gcc

    3、智能指针概念

    智能指针(Smart pointers)是存储“指向动态分配(在堆上)的对象的指针”的对象。也就是说,智能指针其实是个对象。不过它的行为很像C++的内建指针,只是它们可以在适当的时候自动删除它们所指向的对象。智能指针在面对异常时有非常显著的作用,它们可以确保动态分配对象的完全析构。它们还可以用于跟踪多主人共享的动态分配对象。在概念上,智能指针可以看作拥有它所指向的对象,并因此在对象不再需要时负责将它删除。

    4、源码解析

    4.1、shared_ptr解析

    4.1.1、shared_ptr

    shared_ptr位于libstdc++-v3\include\bits\shared_ptr.h

    template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
    public:
    ...
    	// 构造函数
    	template<typename _Tp1>
    	explicit shared_ptr(_Tp1* __p)
    		:__shared_ptr<_Tp>(__p)
    	{
    	}
    ...
    };
    

    由于源代码过长,这里就只贴出其中一部分进行分析:

    1. 该类没有类成员
    2. 该类继承于__shared_ptr,构造函数也只是调用了__shared_ptr的构造函数而已,将接管的普通指针传递给__shared_ptr
    3. 该类没有重载*->运算符,从这点看shared_ptr似乎无法实现普通指针的功能,推测这两个运算符的重载是在父类__shared_ptr实现的
    4. 该类没有析构函数,从智能指针最终会自动释放内存的特性来看,释放工作肯定不是在该类进行了,接下来分析父类__shared_ptr的实现

    4.1.2、__shared_ptr

    __shared_ptr位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    {
    public:
        typedef _Tp element_type;
    ...
    	// 构造函数
    	template<typename _Tp1>
    	explicit __shared_ptr(_Tp1* __p)
    		:_M_ptr(__p), _M_refcount(__p)
    	{
    		__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
    		static_assert( !is_void<_Tp>::value, "incomplete type" );
    		static_assert( sizeof(_Tp1) > 0, "incomplete type" );
    		__enable_shared_from_this_helper(_M_refcount, __p, __p);
    	}
    
    	// 析构函数
    	~__shared_ptr() = default;
    
    	typename std::add_lvalue_reference<_Tp>::type
    	operator*() const noexcept
    	{
    		_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
    		return *_M_ptr;
    	}
    
    	_Tp*
    	operator->() const noexcept
    	{
    		_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
    		return _M_ptr;
    	}
    ...
    
    private:
        _Tp* _M_ptr;    // Contained pointer.
        __shared_count<_Lp> _M_refcount;    // Reference counter.
    };
    

    同样的,源代码比较长且不是分析的重点,所以只贴出一部分进行分析:

    1. 可以看到里面有两个类成员:_M_ptr(由智能指针接管的普通指针)、_M_refcount(引用计数器,类型为__shared_count)
    2. 从构造函数看,_M_ptr获得了接管的普通指针的值,而_M_refcount的构造也同样需要这个值
    3. 重载了*->运算符,由shared_ptr继承使用,使得智能指针最终能拥有和普通指针一样行为,尽管智能指针本质上是一个对象
    4. 从析构函数来看,里面啥也没做,说明接管的普通指针也不是在这里释放的,所以有可能是由_M_refcount来完成释放内存这个工作,下面分析__shared_count的实现

    4.1.3、__shared_count

    __shared_count位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<_Lock_policy _Lp>
    class __shared_count
    {
    public:
        constexpr __shared_count() noexcept : _M_pi(0)
        {
        }
    
        template<typename _Ptr>
        explicit __shared_count(_Ptr __p) : _M_pi(0)
        {
            __try
            {
                _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
            }
            __catch(...)
            {
                delete __p;
                __throw_exception_again;
            }
        }
    
        template<typename _Ptr, typename _Deleter>
        __shared_count(_Ptr __p, _Deleter __d)
            :__shared_count(__p, std::move(__d), allocator<void>())
        {
        }
    
        template<typename _Ptr, typename _Deleter, typename _Alloc>
        __shared_count(_Ptr __p, _Deleter __d, _Alloc __a)
            :_M_pi(0)
        {
            typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
            typedef typename allocator_traits<_Alloc>::template rebind_traits<_Sp_cd_type> _Alloc_traits;
            typename _Alloc_traits::allocator_type __a2(__a);
            _Sp_cd_type* __mem = 0;
            __try
            {
                __mem = _Alloc_traits::allocate(__a2, 1);
                _Alloc_traits::construct(__a2, __mem, __p, std::move(__d), std::move(__a));
                _M_pi = __mem;
            }
            __catch(...)
            {
                __d(__p); // Call _Deleter on __p.
                if (__mem)
                    _Alloc_traits::deallocate(__a2, __mem, 1);
                __throw_exception_again;
            }
        }
    
        template<typename _Tp, typename _Alloc, typename... _Args>
        __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a, _Args&&... __args)
            :_M_pi(0)
        {
            typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
            typedef typename allocator_traits<_Alloc>::template rebind_traits<_Sp_cp_type> _Alloc_traits;
            typename _Alloc_traits::allocator_type __a2(__a);
            _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
            __try
            {
                _Alloc_traits::construct(__a2, __mem, std::move(__a),
                std::forward<_Args>(__args)...);
                _M_pi = __mem;
            }
            __catch(...)
            {
                _Alloc_traits::deallocate(__a2, __mem, 1);
                __throw_exception_again;
            }
        }
    
        template<typename _Tp, typename _Del>
        explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r)
            :_M_pi(0)
        {
            using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
            using _Del2 = typename conditional<is_reference<_Del>::value, reference_wrapper<typename remove_reference<_Del>::type>, _Del>::type;
            using _Sp_cd_type = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
            using _Alloc = allocator<_Sp_cd_type>;
            using _Alloc_traits = allocator_traits<_Alloc>;
            _Alloc __a;
            _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
            _Alloc_traits::construct(__a, __mem, __r.release(), __r.get_deleter());  // non-throwing
            _M_pi = __mem;
        }
    
        explicit __shared_count(const __weak_count<_Lp>& __r);
    
        explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
    
        ~__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<_Lp>* __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<_Lp>* __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; }
    
        void* _M_get_deleter(const std::type_info& __ti) const noexcept
        { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
    
        bool _M_less(const __shared_count& __rhs) const noexcept
        { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
    
        bool _M_less(const __weak_count<_Lp>& __rhs) const noexcept
        { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
    
        friend inline bool operator==(const __shared_count& __a, const __shared_count& __b) noexcept
        { return __a._M_pi == __b._M_pi; }
    
    private:
        friend class __weak_count<_Lp>;
        _Sp_counted_base<_Lp>* _M_pi;
    }
    

    从源代码可以获得以下几点信息:

    1. 有一个类成员:_M_pi(计数器,类型为_Sp_counted_base)
    2. 只有构造函数为_M_pi分配了内存,并且该类并没有直接持有从前面一直传递过来的那个普通指针,而是继续将其传递给_M_pi,所以内存的释放也不是直接在该类进行的。
    3. 拷贝构造函数没有分配内容,而是把拷贝对象的_M_pi直接拿过来了,有点类似于浅拷贝的意思,然后调用了_M_pi_M_add_ref_copy方法(后面会讲),增加了一次引用计数。赋值函数也是同样的道理,但是由于赋值函数的特殊性(当赋值对象原先就存在时调用赋值函数,否则调用拷贝构造函数),要先调用_M_pi_M_release方法(后面会讲)将自己持有的内存释放掉,其余操作和拷贝构造函数是一样的
    4. 从析构函数中可以看到,里面并没有直接释放掉为_M_pi分配的内存,而是调用了_M_pi_M_release方法,可以大概猜测是通过_M_release方法释放了_M_pi的内存(delete this指针,后面会讲)
    5. 由于__shared_count里面的方法都是借助_M_pi实现的,并且到这里都还没有见到释放那个普通指针的代码,所以还是得继续看_M_pi究竟做了什么工作,接下来继续看_Sp_counted_base的实现

    4.1.4、_Sp_counted_base

    _Sp_counted_base位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base : public _Mutex_base<_Lp>
    {
    public:
        _Sp_counted_base() noexcept
            : _M_use_count(1), _M_weak_count(1)
        {
        }
      
        virtual ~_Sp_counted_base() noexcept
        {
        }
    
        virtual void _M_dispose() noexcept = 0;
      
        virtual void _M_destroy() noexcept
        { delete this; }
    
        virtual void* _M_get_deleter(const std::type_info&) noexcept = 0;
    
        void _M_add_ref_copy()
        { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
    
        void _M_add_ref_lock();
    
        bool _M_add_ref_lock_nothrow();
    
        void _M_release() noexcept
        {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
            if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
            {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
                _M_dispose();
                if (_Mutex_base<_Lp>::_S_need_barriers)
                {
                    _GLIBCXX_READ_MEM_BARRIER;
                    _GLIBCXX_WRITE_MEM_BARRIER;
                }
    
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
                if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
                {
                    _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
                    _M_destroy();
                }
            }
        }
    
        void _M_weak_add_ref() noexcept
        { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
    
        void _M_weak_release() noexcept
        {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
            if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
            {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
                if (_Mutex_base<_Lp>::_S_need_barriers)
                {
                    _GLIBCXX_READ_MEM_BARRIER;
                    _GLIBCXX_WRITE_MEM_BARRIER;
                }
                _M_destroy();
            }
        }
    
        long _M_get_use_count() const noexcept
        {
            return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
        }
    
    private:
        _Sp_counted_base(_Sp_counted_base const&) = delete;
        _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
    
        _Atomic_word  _M_use_count;     // #shared
        _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
    };
    

    从源代码可以获得以下几点信息:

    1. 有两个类成员:_M_use_count(引用计数)、_M_weak_count(弱引用计数),对这两个数的操作需要具有原子性
    2. _M_release方法是该类的关键,可以看到先将_M_use_count自减1,然后判断自减前_M_use_count的值是否为1(无其他人引用),如果为1,则调用_M_dispose方法(虚函数,由派生类实现,估计是释放前面一直说的那个由智能指针接管的普通指针)。接下来将_M_weak_count自减1,然后判断自减前_M_weak_count的值是否为1(无其他人引用),如果为1,则调用_M_destroy方法,而_M_destroy方法里面释放了this指针,这点和前面的猜测一致
    3. _M_release可以看出,智能指针所接管的指针的释放内存工作只和_M_use_count有关,当_M_use_count减完时就会将其释放了,而_M_weak_count也是有作用的,他负责释放_Sp_counted_base本身,这也就是为什么weak_ptr可以保证智能指针这个对象有效,但不保证智能指针所引用的指针有效的原因了(这点和shared_ptr、weak_ptr的定义是完全一致的)
    4. 其他的方法就很简单了,比如_M_add_ref_copy方法将引用计数_M_use_count加一,_M_weak_add_ref方法将弱引用计数_M_weak_count加一,这个自增过程是具有原子性的,这里就不赘述了,大家可以自行看一下具体实现

    4.1.5、_Sp_counted_ptr

    _Sp_counted_ptr位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<typename _Ptr, _Lock_policy _Lp>
    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
    {
    public:
        explicit _Sp_counted_ptr(_Ptr __p) noexcept : _M_ptr(__p)
        {
        }
    
        virtual void _M_dispose() noexcept
        { delete _M_ptr; }
    
        virtual void _M_destroy() noexcept
        { delete this; }
    
        virtual void* _M_get_deleter(const std::type_info&) noexcept
        { return nullptr; }
    
        _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
        _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
    
    private:
        _Ptr _M_ptr;
    };
    
    1. 从源代码中可以看到_Sp_counted_ptr_Sp_counted_base的派生类,并且__shared_count在初始化_M_pi时用的也是_Sp_counted_ptr
    2. 接着看_M_dispose方法的实现,里面确实删除了一开始shared_ptr接管的指针,_M_destroy方法用于释放自己的内存(由__shared_count调用),和前面猜想一致

    4.1.6、shared_ptr总结

    看完前面分析的内容再回过头来看,_Sp_counted_base_M_add_ref_copy方法是整个流程的关键,它实现了引用计数器的增加,那么在何时调用它就是关键了。通过在代码中检索,可以查到__shared_count的赋值构造函数和拷贝构造函数调用了它(其实也只有可能是这里啦,因为只有它的类成员有_Sp_counted_base),这样整个流程也就解释通了:

    1. __shared_count的成员_M_pi只会初始化一次(构造函数中分配内存初始化的)
    2. 后面调用拷贝构造时(这个行为由__shared_ptr触发,__shared_ptr的拷贝构造函数和赋值函数都会调用__shared_count的拷贝构造函数),__shared_count只是简单复制了_M_pi而已,并没有重新分配内存,然后再调用_M_add_ref_copy增加一次引用计数,这样就实现了shared_ptr每多一份拷贝就增加一次引用计数的特性了
    3. 每一个__shared_count被析构都会使引用计数减一,减完就将智能指针持有的资源释放,这个前面已经分析过了,这里就不赘述了

    4.2、weak_ptr解析

    4.2.1、weak_ptr

    weak_ptr位于libstdc++-v3\include\bits\shared_ptr.h

    template<typename _Tp>
    class weak_ptr : public __weak_ptr<_Tp>
    {
    public:
    	constexpr weak_ptr() noexcept
    		:__weak_ptr<_Tp>()
    	{
    	}
    
    	template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
    	weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
    		:__weak_ptr<_Tp>(__r)
    	{
    	}
    
    	template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
    	weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
    		:__weak_ptr<_Tp>(__r)
    	{
    	}
    
    	template<typename _Tp1>
    	weak_ptr& operator=(const weak_ptr<_Tp1>& __r) noexcept
    	{
    		this->__weak_ptr<_Tp>::operator=(__r);
    		return *this;
    	}
    
    	template<typename _Tp1>
    	weak_ptr& operator=(const shared_ptr<_Tp1>& __r) noexcept
    	{
    		this->__weak_ptr<_Tp>::operator=(__r);
    		return *this;
    	}
    
    	shared_ptr<_Tp>
    	lock() const noexcept
    	{
    		return shared_ptr<_Tp>(*this, std::nothrow);
    	}
    }
    

    从源代码中可以看出以下几点:

    1. 该类没有类成员
    2. 从构造函数的参数来看(无参构造函数除外),只能使用shared_ptrweak_ptr来构造一个weak_ptr对象,包括赋值函数也是这样的,这就和shared_ptr有很大区别了,从4.1.1小节可以看到shared_ptr是可以使用普通指针来构造的
    3. 可以调用lock方法来获得一个shared_ptrlock方法的实现后面再讲
    4. 该类没有重载*->运算符,接下来分析其父类__weak_ptr的实现

    4.2.2、__weak_ptr

    __weak_ptr位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<typename _Tp, _Lock_policy _Lp>
    class __weak_ptr
    {
    public:
    	typedef _Tp element_type;
    
    	constexpr __weak_ptr() noexcept
    		:_M_ptr(0)
    		,_M_refcount()
    	{
    	}
    
    	__weak_ptr(const __weak_ptr&) noexcept = default;
    	__weak_ptr& operator=(const __weak_ptr&) noexcept = default;
    	~__weak_ptr() = default;
    	
    	template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
    	__weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
    		:_M_refcount(__r._M_refcount)
    	{ _M_ptr = __r.lock().get(); }
    
    	template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
    	__weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    		:_M_ptr(__r._M_ptr)
    		,_M_refcount(__r._M_refcount)
    	{
    	}
    
    	template<typename _Tp1>
    	__weak_ptr& operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
    	{
    		_M_ptr = __r.lock().get();
    		_M_refcount = __r._M_refcount;
    		return *this;
    	}
    
    	template<typename _Tp1>
    	__weak_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    	{
    		_M_ptr = __r._M_ptr;
    		_M_refcount = __r._M_refcount;
    		return *this;
    	}
    
    	__shared_ptr<_Tp, _Lp> lock() const noexcept
    	{ return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
    
    	long use_count() const noexcept
    	{ return _M_refcount._M_get_use_count(); }
    
    	bool expired() const noexcept
    	{ return _M_refcount._M_get_use_count() == 0; }
    
    	template<typename _Tp1>
    	bool owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
    	{ return _M_refcount._M_less(__rhs._M_refcount); }
    
    	template<typename _Tp1>
    	bool owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
    	{ return _M_refcount._M_less(__rhs._M_refcount); }
    
    	void reset() noexcept
    	{ __weak_ptr().swap(*this); }
    
    	void swap(__weak_ptr& __s) noexcept
    	{
    		std::swap(_M_ptr, __s._M_ptr);
    		_M_refcount._M_swap(__s._M_refcount);
    	}
    
    private:
    	// Used by __enable_shared_from_this.
    	void _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    	{
    		_M_ptr = __ptr;
    		_M_refcount = __refcount;
    	}
    
    	template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    	template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    	friend class __enable_shared_from_this<_Tp, _Lp>;
    	friend class enable_shared_from_this<_Tp>;
    
    	_Tp* _M_ptr;         // Contained pointer.
    	__weak_count<_Lp> _M_refcount;    // Reference counter.
    }
    

    从源代码中可以看出以下几点信息:

    1. 有两个类成员:_M_ptr(由智能指针接管的普通指针)、_M_refcount(弱引用计数器,类型为__weak_count)
    2. 从构造函数看,_M_ptr获得了接管的普通指针的值,而_M_refcount的构造并不需要这个值了(这点和__shared_ptr不一样了),_M_refcount只能借助其他__shared_ptr_M_refcount或者__weak_ptr_M_refcount来进行构造(注意这两个的_M_refcount类型不同,说明__weak_count支持多种类型进行构造)
    3. 拷贝构造函数和赋值函数的实现同上
    4. 该类依然没有重载*->运算符,由于接下去已无继承关系,所以weak_ptr不具备普通指针的特性,无法直接使用资源,这点符合weak_ptr的定义
    5. 既然weak_ptr无法直接使用资源,那他设计_M_ptr这个成员的意图在哪里呢?答案就是lock方法将weak_ptr转换为shared_ptr时是需要将这个指针传递过去的,不然连接管的指针都没了转换的意义也就没了
    6. 析构函数啥也没做,因为weak_ptr不持有资源,不对资源的释放产生影响,接下来对__weak_count进行分析

    4.2.3、__weak_count

    __weak_count的实现位于libstdc++-v3\include\bits\shared_ptr_base.h

    template<_Lock_policy _Lp>
    class __weak_count
    {
    public:
    	constexpr __weak_count() noexcept : _M_pi(0)
    	{
    	}
    
    	__weak_count(const __shared_count<_Lp>& __r) noexcept
    		:_M_pi(__r._M_pi)
    	{
    		if (_M_pi != 0)
    			_M_pi->_M_weak_add_ref();
    	}
    
    	__weak_count(const __weak_count<_Lp>& __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<_Lp>&
    	operator=(const __shared_count<_Lp>& __r) noexcept
    	{
    		_Sp_counted_base<_Lp>* __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<_Lp>& operator=(const __weak_count<_Lp>& __r) noexcept
    	{
    		_Sp_counted_base<_Lp>* __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<_Lp>& __r) noexcept
    	{
    		_Sp_counted_base<_Lp>* __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_less(const __weak_count& __rhs) const noexcept
    	{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
    
    	bool _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    	{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
    
    	friend inline bool operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    	{ return __a._M_pi == __b._M_pi; }
    
    private:
    	friend class __shared_count<_Lp>;
    	_Sp_counted_base<_Lp>*  _M_pi;
    }
    

    从源代码可以获得以下几点信息:

    1. 有一个类成员:_M_pi(计数器,类型为_Sp_counted_base)
    2. 仔细一看__shared_count里也持有这个成员,类型一模一样,这样也就解释得通为什么__shared_count__weak_count可以互相转换了,转换的方式很简单:
    • __shared_count转换为__weak_count的过程为:
      拷贝_M_pi,然后调用_M_weak_add_ref方法增加一次弱引用计数
    • __weak_count转换为__shared_count的过程为:
      拷贝_M_pi,然后调用_M_add_ref_copy方法增加一次引用计数
    1. 构造函数、拷贝构造函数、赋值函数均不为_M_pi分配了内存,这点也可以看出weak_ptr确实是shared_ptr的附属品而已,自己不持有资源不控制资源
    2. 析构函数中调用了_M_pi_M_weak_release方法,释放了_M_pi的内存(条件满足的情况下才会释放)
    3. 接下来的内容和3.1.4小节还有3.1.5小节的内容是一样的,这里就不赘述

    4.2.4、回过头看weak_ptr中lock方法的实现

    1. weak_ptrlock方法调用了shared_ptr的构造函数如下:
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
        :__shared_ptr<_Tp>(__r, std::nothrow)
    {
    }
    
    1. 从上面的代码可以看出调用了__shared_ptr的构造函数,代码如下:
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
        :_M_refcount(__r._M_refcount, std::nothrow)
    {
        _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }
    

    可以看到此时先是使用了__weak_ptr_M_refcount成员(类型为__weak_count)来构造__shared_ptr_M_refcount成员(类型为__shared_count),然后再判断引用计数器是否为0,为零的话就将__shared_ptr_M_ptr成员置为nullptr,即lock函数执行失败;不为零的话就会正常构建一个shared_ptr了。

    1. 上面讲的构造_M_refcount的方法如下所示:
    template<_Lock_policy _Lp>
    inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
        :_M_pi(__r._M_pi)
    {
        if (_M_pi != nullptr)
            if (!_M_pi->_M_add_ref_lock_nothrow())
                _M_pi = nullptr;
    }
    
    template<>
    inline bool _Sp_counted_base<_S_single>::_M_add_ref_lock_nothrow()
    {
        if (_M_use_count == 0)
            return false;
        ++_M_use_count;
        return true;
    }
    

    从上面的代码中我们可以看到,首先__shared_count使用__weak_count_M_pi来构建自己的_M_pi,从前面的分析我们可以知道,在所有的shared_ptrweak_ptr消亡之前,_M_pi的内存是不会被释放的,所以这里就算之前的shared_ptr已经全部消亡(即资源已释放),_M_pi还是有效的(因为weak_ptr还没有消亡)。而通过判断_M_add_ref_lock_nothrow的返回值来确定是否要将_M_pi置为nullptr,可以看到判断的条件为_M_use_count是否为0(即判断资源是否被释放了)。

    1. 接下来再看一下__shared_count_M_get_use_count方法,代码如下:
    long _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
    

    代码比较简单,意思就是如果此时资源已经被释放了(对应_M_pi值为nullptr),则会返回0,再回到上面第2点讲的那里,_M_ptr将被设置为nullptr,即资源无效,lock函数执行失败。
    至此weak_ptrlock方法的实现原理就全部讲解完毕。

    4.3、enable_shared_from_this解析

    4.3.1、从一个典型的例子来认识智能指针的不足之处

    有时候我们需要在一个被shared_ptr管理的对象的内部获取自己的shared_ptr,比如下面这个的例子:

    class Ptr
    {
    public:
    	void fun()
    	{
    		std::shared_ptr<Ptr> p(this);
    		std::cout << sp->use_count() << std::endl;
    	}
    };
    
    std::shared_ptr<Ptr> p= std::make_shared<Ptr>();
    p->fun(); //输出为1
    

    从上面这个简单的例子可以看到,fun输出的居然是1而不是2,这是为什么?倒回去4.1.2小节可以看到,当使用普通指针(上面的那个this)去构造shared_ptr时,构造出来的shared_ptr一定是独立的,不与其他人共享的。这样就会出现一个非常严重的问题,那就是析构时会导致对象被重复释放, 从而引发错误

    4.3.2、改进方法

    现在明确一下我们的需求:在一个对象内部构造该对象的shared_ptr 时,即使该对象已经被shared_ptr管理着,也不会造成对象被两个独立的智能指针管理。这就要求我们在对象内构造对象的智能指针时,必须能识别有对象是否已经由其他智能指针管理,智能指针的数量,并且我们创建智能指针后也能让之前的智能指针感知到。当然标准已经也给出了解决了这个问题办法,那就是使用接下来所提到的enable_shared_from_this

    4.3.3、enable_shared_from_this解析

    enable_shared_from_this的实现位于libstdc++-v3\include\bits\shared_ptr.h

    template<typename _Tp>
    class enable_shared_from_this
    {
    protected:
    	constexpr enable_shared_from_this() noexcept { }
    
    	enable_shared_from_this(const enable_shared_from_this&) noexcept { }
    
    	enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept
    	{ return *this; }
    
    	~enable_shared_from_this() { }
    
    public:
    	shared_ptr<_Tp> shared_from_this()
    	{ return shared_ptr<_Tp>(this->_M_weak_this); }
    
    	shared_ptr<const _Tp> shared_from_this() const
    	{ return shared_ptr<const _Tp>(this->_M_weak_this); }
    
    private:
    	template<typename _Tp1>
    	void _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
    	{ _M_weak_this._M_assign(__p, __n); }
    
    	template<typename _Tp1>
    	friend void __enable_shared_from_this_helper(const __shared_count<>& __pn, const enable_shared_from_this* __pe, const _Tp1* __px) noexcept
    	{
    		if (__pe != 0)
    			__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
    	}
    
    	mutable weak_ptr<_Tp>  _M_weak_this;
    };
    

    从源代码可以获得以下几点信息:

    1. 有一个类成员:_M_weak_this
    2. 该类需要被继承,被需要用智能指针管理的对象继承
    3. 我们平时就是使用该类的shared_from_this方法的,可以看到其实现就是利用_M_weak_this构造一个shared_ptr对象而已
    4. 该类并没有直接初始化_M_weak_this,而是提供了_M_weak_assign方法来构造_M_weak_this,其实现比较简单,就是调用了weak_ptr_M_assign方法
    5. 那么问题来了,_M_weak_assign方法由谁调用呢?从后面我们可以知道是由一个全局函数__enable_shared_from_this_helper调用的,该函数有一种重载形式是enable_shared_from_this的友元函数,从上面的代码中就可以看到了,那唯一一个友元函数就是__enable_shared_from_this_helper,里面调用了enable_shared_from_this_M_weak_assign方法。
    6. __enable_shared_from_this_helper函数要在哪个时间点使用才能达到预期的效果呢?答案当然是在__shared_ptr的构造函数中调用。下面列出了__shared_ptr部分构造函数,可以看到确实调用了__enable_shared_from_this_helper,证实了前面的猜想
    template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    {
    public:
    ...
    
    	template<typename _Tp1>
    	explicit __shared_ptr(_Tp1* __p)
    		:_M_ptr(__p)
    		,_M_refcount(__p)
    	{
    		__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
    		static_assert( !is_void<_Tp>::value, "incomplete type" );
    		static_assert( sizeof(_Tp1) > 0, "incomplete type" );
    		__enable_shared_from_this_helper(_M_refcount, __p, __p);
    	}
    
    	template<typename _Tp1, typename _Deleter>
    	__shared_ptr(_Tp1* __p, _Deleter __d)
    		:_M_ptr(__p)
    		,_M_refcount(__p, __d)
    	{
    		__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
    		__enable_shared_from_this_helper(_M_refcount, __p, __p);
    	}
    
    	template<typename _Tp1, typename _Deleter, typename _Alloc>
    	__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
    		:_M_ptr(__p)
    		,_M_refcount(__p, __d, std::move(__a))
    	{
    		__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
    		__enable_shared_from_this_helper(_M_refcount, __p, __p);
    	}
    
    ...
    };
    

    4.3.4、__enable_shared_from_this_helper解析

    __enable_shared_from_this_helper的实现位于libstdc++-v3\include\bits\shared_ptr_base.h

    // Friend of enable_shared_from_this.
    template<typename _Tp1, typename _Tp2>
    void __enable_shared_from_this_helper(const __shared_count<>&, const enable_shared_from_this<_Tp1>*, const _Tp2*) noexcept;
    
    template<_Lock_policy _Lp>
    inline void __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
    { }
    

    这里有必要再看一下__enable_shared_from_this_helper函数的实现,有两种形式,第一种就是上面提到过的那个enable_shared_from_this的友元函数,而第二种重载形式里面啥都没有干。为什么需要重载这两个函数呢?答案很简单,当我们一个类继承了enable_shared_from_this之后,这个类肯定可以转换为enable_shared_from_this类型了,此时在__shared_ptr中调用的__enable_shared_from_this_helper就是上面第一种情况了,这种情况下就可以使用shared_from_this函数了;反之,当类没有继承enable_shared_from_this时,就是调用第二中形式的__enable_shared_from_this_helper,此时也就不能使用shared_from_this函数了。
    至此,为什么在使用shared_from_this前,对应的类需要继承enable_shared_from_this的原因也就全部揭晓了。

    5、总结

    本文先是简单介绍了C++智能指针的定义,然后通过对源码进行详细分析,我们了解了shared_ptrweak_ptr以及enable_shared_from_this的实现原理。源代码内容并不是很复杂,没有用到什么很高深的语法糖,但是阅读起来非常绕(因为这三个类的关联错综复杂),这就需要我们有耐心地一步一步去深入学习。

    最后,如果大家觉得本文写得好的话麻烦点赞收藏关注一下谢谢,也可以关注该专栏,以后会有更多优质文章输出的。

    展开全文
  • 实现了标准库中的function和bind以及智能指针,linux/windows通用。由于公司GCC版本较老,嵌入式的gcc也无法由我来控制,windows上使用的一些类似智能指针,在linux上无法使用,甚是不爽,于是自己手动写了一份,...
  • 智能指针是存储指向动态分配(堆)对象的类,用于生存期控制,能够确保在离开指针所在作用...C++11 提供了 3 种智能指针:std::shared_ptr,std::uniq_ptr,std::weak_ptr,使用时需要引用头文件<memory>。 ...


    前言

    智能指针(Smart Pointer)是存储指向动态分配(堆)对象的类,用于生存期控制,能够确保在离开指针所在作用域时,自动正确地销毁动态分配的对象,防止内存泄露。它的一种通用实现技术是使用引用计数。每使用它一次,内部的引用计数加1,每析构一次,内部引用计数减1,减为0时,删除所指向的堆内存。
    C++11 提供了 3 种智能指针:std::shared_ptr,std::uniq_ptr,std::weak_ptr,使用时需要引用 memory 头文件。


    一、std::shared_ptr 共享的智能指针

    std::shared_ptr使用引用计数,每一个 std::shared_ptr 的拷贝都指向相同的内存。在最后一个 std::shared_ptr 析构的时候,内存才会被释放。。

    1.1 std::shared_ptr 的基本用法

    1. 初始化

    可以通过构造函数、std::make_shared 辅助函数和 reset 方法来初始化 shared_ptr,代码如下:

    //=============== std::shared_ptr 的初始化 ==================
    	std::shared_ptr<int> p(new int(1));
    	std::shared_ptr<int> p2 = p;
    	std::shared_ptr<int> ptr;
    	ptr.reset(new int(1));
    	if (ptr) {
    		cout << "shared ptr is initialized.";
    	}
    

    我们应该优先使用 std::make_shared 来构造智能指针,因为它更高效。

    2. 获取原始指针

    当需要获取原始指针时,可以通过 get 方法来返回原始指针,代码如下:

    std::shared_ptr<int> ptr(new int(1));
    int* p = ptr.get();
    

    3. 指定删除器

    智能指针初始化可以指定删除器,代码如下:

    void DeleteIntPtr(int* p) {
    	delete p;
    }
    std::shared_ptr<int> p(new int, DeleteIntPtr);
    

    当 p 的引用计数为 0 时,自动调用删除器 DeleteIntPtr 来释放对象的内存。删除器可以是一个 lambda表达式,因此,上面的写法还可以改为:

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

    当我们用 shared_ptr 管理动态数组时,需要指定删除器,因为 std::shared_ptr 的默认删除器不支持数组对象,代码如下:

    std::shared_ptr<int> p(new int[10], [](int* p){delete[] p;});  //指定 delete[]
    

    也可以将 std::default_delate 作为删除器。default_delate 的内部是通过调用 delete 来实现功能的,代码如下:

    std::shared_ptr<int> p(new int[10], std::default_delete<int[]>);  
    

    另外,还可以通过封装一个 make_shared_array 方法来让 shared_ptr 支持数组,代码如下:

    template<typename T>
    shared_ptr<T> make_shared_array(size_t size) {
    	return shared_ptr<T>(new T[size], default_delete<T[]>());
    }
    
    //test
    std::shared_ptr<int> p = make_shared_array<int>(10);
    

    1.2 使用 shared_ptr 需要注意的问题

    1)不要用一个原始指针初始化多个 shared_ptr,例如下面这样就是错误的:

    int *ptr = new int;
    std::shared_ptr<int> p1(ptr);
    std::shared_ptr<int> p2(ptr);   //logic error
    

    2) 不要在函数实参中创建 shared_ptr,

    function (shared_ptr<int>(new int), g());  //有缺陷
    

    因为 C++ 的函数参数的计算顺序在不同的编译器上调用可能是不一样的。一般是从右到左,但也有可能是从左到右。所以可能的过程是先 new int,然后调用 g(),如果恰好 g() 发生异常,而 shared_ptr 还没有创建,则 int 内存泄漏了,正确的写法应该是先创建智能指针,代码如下:

    shared_ptr<int> p(new int());
    f(p, g());
    

    3)不要将 this 指针通过 shared_ptr 返回出来,因为 this 本质上是一个裸指针,这样会导致重复析构。通过 shared_from_this 返回 this 指针。

    struct A 
    {
    	shared_ptr<A>GetSelf()
    	{
    		return shared_ptr<S>(this);   //don't do this;
    	}
    };
    
    int main()
    {
    	shared_ptr<A> sp1(new A);
    	shared_ptr<A> sp2 = sp1->GetSelf();
    	return 0;
    }
    

    在这个例子中,由于用同一个指针(this)构造了两个智能指针 sp1 和 sp2,而它们之间是没有任何关系的,在离开作用域之后 this 将会被构造的两个智能指针各自析构,导致重复析构的错误。
    正确返回 this 的shared_ptr 的做法是:让目标类通过派生 std::enable_shared_from_this 类,然后使用基类的成员函数 shared_from_this 来返回 this 的 shared_ptr,示例如下:

    class A : public std::enable_shared_from_this<A>
    {
    	std::shared_ptr<A> GetSelf()
    	{
    		return shared_from_this();
    	}
    };
    std::shared_ptr<A> spy(new A);
    std::shared_ptr<A> p = spy->GetSelf();     //OK
    
    • 避免循环引用,智能指针最大的一个陷阱是循环引用,循环引用会导致内存泄漏。
    struct A;
    struct B;
    
    struct A {
    	std::shared_ptr<B> bptr;
    	~A() {
    		cout << "A is deleted!" << endl;
    	}
    };
    
    struct B {
    	std::shared_ptr<A> aptr;
    	~B() {
    		cout << "B is deleted!" << endl;
    	}
    };
    
    void testPtr() {
    	std::shared_ptr<A> ap(new A);
    	std::shared_ptr<B> bp(new B);
    	ap->bptr = bp;
    	bp->aptr = ap;
    }
    

    测试结果是两个指针A 和B都不会被删除,存在内存泄漏。循环引用导致 ap 和 bp 的引用计数为 2,在离开作用域之后,ap 和 bp 的引用计数减为1,并不会为 0,导致两个指针都不会被析构,产生了内存泄漏。解决办法是把 A 和 B 任何一个成员变量改为 weak_ptr。

    二、unique_ptr 独占的智能指针

    1. unique_ptr 基本用法

    1.1 unique_ptr 的移动

    unique_ptr 是一个独占型的智能指针,它不允许其他的智能指针共享其内容的指针,不允许通过赋值将一个 unique_ptr 赋值给另外一个 unique_ptr。下面用法是错误的:

    unique_ptr<T> myPtr(new T);
    unique_ptr<T> myOtherPtr = myPtr;    //错误,不能赋值
    

    unique_ptr 不允许复制,但可以通过函数返回给其他的 unique_ptr,还可以通过 std::move 来转移到其他的 unique_ptr,这样它本身就不再拥有原来指针的所有权了,例如:

    unique_ptr<T> myPtr(new T);
    unique_ptr<T> myOtherPtr = std::move(myPtr);  //OK
    unique_ptr<T> ptr = myPtr;                    //错误,只能移动,不可复制
    

    unique_ptr 不像 shared_ptr 可以通过 make_shared 方法来创建智能指针,C++11 目前还没有提供 make_unique 方法。

    1.2 指定数组

    unique_ptr 和 shared_ptr 相比,unique_ptr 除了独占这个特点之外,还可以指向一个数组:

    std::unique_ptr<int []> ptr(new int[10]);
    ptr[9] = 9;
    
    //而下面的写法是不合法的
    std::shared_ptr<int []> ptr(new int[10]);    //不合法
    

    1.3 指定删除器

    unique_ptr 指定删除器和 shared_ptr 是有差别的,比如:

    std::shared_ptr<int> ptr(new int(1), [](int* p){delete p;});   //正确
    std::unique_ptr<int> ptr(new int(1), [](int* p){delete p;});   //错误
    

    std::unique_ptr 指定删除器的时候需要确定删除器的类型,所以不能像 shared_ptr 那样直接指定删除器,可以这样写:

    std::unique_ptr<int, void(*)(int*)> ptr(new int(1), [](int *p) {delete p;}); 
    

    上面这种写法在 lambda 没有捕获变量的情况下是正确的,如果捕获了变量,则会编译报错:

    std::unique_ptr<int, void(*)(int*)> ptr(new int(1), [&](int *p) {delete p;}); //错误,捕获了变量
    

    这是因为 lambda 在没有捕获变量的情况下是可以直接转换为函数指针的,一旦捕获了就无法转换了。如果希望 unique_ptr 的删除器支持 lambda,可以这样写:

    std::unique_ptr<int, std::function<void(int*)>> ptr(new int(1), [&](int *p){delete p;});
    

    还可以自定义 unique_ptr 的删除器,比如下面的代码:

    #include <memory>
    #include <functional>
    using namespace std;
    
    struct MyDeleter
    {
    	void operator()(int* p)
    	{
    		cout<<"delete"<<endl;
    		delete p;
    	}
    };
    
    int main()
    {
    	std::unique_ptr<int, MyDeleter> p(new int(1));
    	return 0;
    }
    

    关于 shared_ptr 和 unique_ptr 的使用场景要根据实际应用需求来选择,如果希望只有一个智能指针管理资源或者管理数组就用 unique_ptr,如果希望多个智能指针管理同一个资源就用 shared_ptr。

    三、weak_ptr 弱引用的智能指针

    弱引用指针 weak_ptr 是用来监视 shared_ptr 的,不会使引用计数加1,它不管理 shared_ptr 内部的指针,主要是为了监视 shared_ptr 的生命周期,更像是 shared_ptr 的一个助手。weak_ptr 没有重载操作符*和->,因为它不共享指针,不能操作资源,主要是为了通过 shared_ptr 获得资源的检测权,它的构造不会增加引用计数,它的析构也不会减少引用计数,纯粹只是作为一个旁观者来监视 shared_ptr 中管理的资源是否存在。weak_ptr 还可以用来返回 this 指针和解决循环引用的问题。

    1. weak_ptr 基本用法

    1)通过 use_count() 方法获得当前观测资源的引用计数,代码如下:

    shared_ptr<int> sp(new int(10));
    weak_ptr<int> wp(sp);
    cout<<wp.use_count()<<endl;    //结果输出1
    

    2)通过 expired() 方法判断所检测的资源是否已经被释放,代码如下:

    shared_ptr<int> sp(new int(10));
    weak_ptr<int> wp(sp);
    if (wp.expired())
    {
    	std::cout << "weak_ptr 无效,所监测的智能指针已被释放\n";
    }
    else
    {
    	std::cout << "weak_ptr 有效\n";
    }
    
    //结果输出: weak_ptr 有效
    

    3)通过 lock 方法来获取所监视的 shared_ptr,代码如下:

    std::weak_ptr<int> gw;
    void f()
    {
    	if (gw.expired())
    	{
    		std::cout << "gw is expired\n";
    	}
    	else
    	{
    		auto spt = gw.lock();
    		std::cout << *spt << "\n";
    	}
    }
    
    int main()
    {
    	{
    		auto sp = std::make_shared<int>(42);
    		gw = sp;
    		f();
    	}
    	f();
    	return 0;
    }
    
    //输出如下:
    42
    gw is expired
    

    2. weak_ptr 返回 this 指针

    上面提到不能将 this 指针返回为 shared_ptr,需要通过派生 std::enable_shared_from_this 类,并通过其方法 shared_from_this 来返回智能指针,原因是 std::enable_shared_from_this 类中有一个 weak_ptr,这个 weak_ptr 用来观测 this 智能指针,调用 shared_from_this() 方法时,会调用内部这个 weak_ptr 的 lock() 方法,将所观测的 shared_ptr 返回。再看一下前面的例子:

    struct A : public std::enable_shared_from_this<A>
    {
    	std::shared_ptr<A> GetSelf()
    	{
    		return shared_from_this();
    	}
    
    	~A()
    	{
    		cout << "A is deleted" << endl;
    	}
    };
    
    int main()
    {
    	std::shared_ptr<A> spy(new A);
    	std::shared_ptr<A> p = spy->GetSelf();
    	return 0;
    }
    
    //输出结果: A is deleted
    

    在外面创建 A 对象的智能指针和通过该对象返回 this 的智能指针都是安全的,因为 shared_from_this() 是内部的 weak_ptr 调用 lock() 方法之后返回的智能指针,在离开作用域后,spy 的引用计数减为0,A 对象会被析构,不会出现 A 对象被析构两次的问题。

    需要注意的是,获取自身智能指针的函数仅在 shared_ptr 的构造函数被调用之后才能使用,因为 enable_shared_from_this 内部的 weak_ptr 只有通过 shared_ptr 才能构造。

    3. weak_ptr 解决循环引用的问题

    上面提到因为智能指针的循环引用导致内存泄漏的问题,再看一下其示例:

    struct A;
    struct B;
    
    struct A {
    	std::shared_ptr<B> bptr;
    	~A() {
    		cout << "A is deleted!" << endl;
    	}
    };
    
    struct B {
    	std::shared_ptr<A> aptr;
    	~B() {
    		cout << "B is deleted!" << endl;
    	}
    };
    
    void testPtr() {
    	std::shared_ptr<A> ap(new A);
    	std::shared_ptr<B> bp(new B);
    	ap->bptr = bp;
    	bp->aptr = ap;
    	std::cout << "ap use count: " << ap.use_count() << endl;
    	std::cout << "bp use count: " << bp.use_count() << endl;
    }
    
    int main()
    {
    	testPtr();
    	return 0;
    }
    
    //输出如下:
    ap use count: 2
    bp use count: 2
    

    在这个例子中由于循环引用导致 ap 和 bp 的引用计数都为2,离开作用域之后引用计数减为1,不会去删除指针,导致内存泄漏。通过 weak_ptr 就可以解决这个问题,只要将 A 或 B 的任意一个成员变量改为 weak_ptr 即可。

    struct A;
    struct B;
    
    struct A {
    	std::shared_ptr<B> bptr;
    	~A() {
    		cout << "A is deleted!" << endl;
    	}
    };
    
    struct B {
    	//std::shared_ptr<A> aptr;
    	std::weak_ptr<A> aptr;   //改为 weak_ptr
    	~B() {
    		cout << "B is deleted!" << endl;
    	}
    };
    
    void testPtr() {
    	std::shared_ptr<A> ap(new A);
    	std::shared_ptr<B> bp(new B);
    	ap->bptr = bp;
    	bp->aptr = ap;
    	std::cout << "ap use count: " << ap.use_count() << endl;
    	std::cout << "bp use count: " << bp.use_count() << endl;
    }
    
    
    //输出结果:
    ap use count: 1
    bp use count: 2
    A is deleted!
    B is deleted!
    

    这样在对 B 的成员赋值时,即执行 bp->aptr = ap; 时, 由于 aptr 是 weak_ptr,它并不会增加引用计数,所以 ap 的引用计数仍然是1,在离开作用域之后,ap 的引用计数会减为0,A指针会被析构,析构后其内部的 bptr 的引用计数减为1,然后在离开作用域后 bp 引用计数又从1减为0,B对象也会被析构,不会发生内存泄露。


    展开全文
  • 总体而言,实现shared_ptr、weak_ptr智能指针是通过两个基类_Ref_count_base、_Ptr_base以及它们的派生类来实现的,其结构图如下: 1、抽象类_Ref_count_base class _Ref_count_base { // common code for ...
  • 一、介绍 share_ptr包装了new操作符在堆上分配的动态对象,但他实现的是计数型的智能指针,share_ptr早期的名字就是counter_ptr,可以自由拷贝和赋值,...class shared_ptr { public: typedef T element_type; //
  • shared_ptr的坑

    2020-09-26 17:21:45
    shared_ptr 原理及事故 new与赋值的坑 赋值(assignment)和new运算符在C++与Java(或C#)中的行为有本质的区别。在Java中,new是对象的构造,而赋值运算是引用的传递;而在C++中,赋值运算符意味着"构造",或者"值...
  • 因为动态内存的使用我们很容易忘记释放内存,容易造成内存的...weak_ptr:指向shared_ptr所管理的对象,防止循环引用等。 智能指针的用法和普通指针没有什么区别: 1.shared_ptr 初始化方式: **初始化为指针为空。*
  • 以下是正文: 我在《Linux 多线程服务端编程:使用 muduo C++ 网络库》第 1.9 节“再论 shared_ptr 的线程安全”中写道: (shared_ptr)的引用计数本身是安全且无锁的,但对象的读写则不是,因为 shared_ptr 有两个...
  • 【C++】shared_ptr共享型智能指针详解

    千次阅读 2020-04-27 13:36:39
    指针是C/C++区别于其他语言的最强大的语法特性,借助指针,C/C++可以直接操纵内存内容。但是,指针的引入也带来了一些使用上的困难,这要求程序员自己必须手动地对分配申请的内存区进行...shared_ptr基本用法 智能...
  • C++ shared_ptr

    2020-06-04 21:52:58
    原文链接:智能指针之shared_ptr 一、shared_ptr类 头文件:#include<memory> 智能指针,是一个模板。创建智能指针时,必须提供指针所指的类型 如果当做提条件判断,则是检测其是否为空 shared_ptr<...
  • std::shared_ptr内存管理和引用计数原理: 默认已经知道了std::shared_ptr的RAII和引用计数,那么是如何实现这个功能的呢? #include <iostream> #include <string> #include <memory> int main...
  • 头文件<memory> 1、std::unique_ptr 声明: template<class T,class Deleter = std::default_delete<... class unique_ptr;... std::unique_ptr是通过指针占有并管理另一对象,并在unique_ptr离开作
  • std::shared_ptr std::shared_ptr是通过指针保持对象共享所有权的智能指针,多个std::shared_ptr引用对象占用同一个对象。当指针对象被另一个对象引用时可以把所有权共享给另一个引用指针对象,被管理的指针是当...
  • 源码分析shared_ptr实现

    2020-05-29 21:13:55
    智能指针是C++中一项很常用的技术,合理的...我们平时看文档都知道shared_ptr内部是使用引用计数来记录托管指针被引用的次数,当托管指针的引用计数为0时会释放托管的内存,这里通过gcc源码探究shared_ptr内部究竟是如

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,638
精华内容 24,655
关键字:

shared_ptr