首页 > 代码库 > C++智能指针 weak_ptr

C++智能指针 weak_ptr

C++智能指针 weak_ptr

  weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段.
  weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少.
  定义在 memory 文件中(非memory.h), 命名空间为 std.

  weak_ptr 使用:

std::shared_ptr<int> sp(new int(10));
std::weak_ptr<int> wp(sp);
wp = sp;
printf("%d\n", wp.use_count()); // 1
wp.reset();
printf("%d\n", wp); // 0

// 检查 weak_ptr 内部对象的合法性.
if (std::shared_ptr<int> sp = wp.lock())
{
}

 

成员函数

weak_ptr 没有重载*和->但可以使用 lock 获得一个可用的 shared_ptr 对象. 注意, weak_ptr 在使用前需要检查合法性.

expired 用于检测所管理的对象是否已经释放, 如果已经释放, 返回 true; 否则返回 false.
lock 用于获取所管理的对象的强引用(shared_ptr). 如果 expired 为 true, 返回一个空的 shared_ptr; 否则返回一个 shared_ptr, 其内部对象指向与 weak_ptr 相同.
use_count 返回与 shared_ptr 共享的对象的引用计数.
reset 将 weak_ptr 置空.
weak_ptr 支持拷贝或赋值, 但不会影响对应的 shared_ptr 内部对象的计数.

 

使用 weak_ptr 解决 shared_ptr 因循环引有不能释放资源的问题

使用 shared_ptr 时, shared_ptr 为强引用, 如果存在循环引用, 将导致内存泄露. 而 weak_ptr 为弱引用, 可以避免此问题, 其原理:
  对于弱引用来说, 当引用的对象活着的时候弱引用不一定存在. 仅仅是当它存在的时候的一个引用, 弱引用并不修改该对象的引用计数, 这意味这弱引用它并不对对象的内存进行管理.
  weak_ptr 在功能上类似于普通指针, 然而一个比较大的区别是, 弱引用能检测到所管理的对象是否已经被释放, 从而避免访问非法内存。
注意: 虽然通过弱引用指针可以有效的解除循环引用, 但这种方式必须在程序员能预见会出现循环引用的情况下才能使用, 也可以是说这个仅仅是一种编译期的解决方案, 如果程序在运行过程中出现了循环引用, 还是会造成内存泄漏.

         class CB;        class CA;             class CA        {        public:            CA(){}            ~CA(){PRINT_FUN();}                 void Register(const std::shared_ptr<CB>& sp)            {                m_spb = sp;            }             private:            std::weak_ptr<CB> m_spb;        };             class CB        {        public:            CB(){};            ~CB(){PRINT_FUN();};                 void Register(const std::shared_ptr<CA>& sp)            {                m_spa = sp;            }             private:            std::shared_ptr<CA> m_spa;        };             std::shared_ptr<CA> spa(new CA);        std::shared_ptr<CB> spb(new CB);             spb->Register(spa);        spa->Register(spb);        printf("%d\n", spb.use_count()); // 1        printf("%d\n", spa.use_count()); // 2

 

 

 

VC中的源码实现

template<class _Ty>class weak_ptr    : public _Ptr_base<_Ty>{    // class for pointer to reference counted resource    typedef typename _Ptr_base<_Ty>::_Elem _Elem;public:    weak_ptr()    {    // construct empty weak_ptr object    }    template<class _Ty2>    weak_ptr(const shared_ptr<_Ty2>& _Other,        typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,        void *>::type * = 0)    {    // construct weak_ptr object for resource owned by _Other        this->_Resetw(_Other);    }    weak_ptr(const weak_ptr& _Other)    {    // construct weak_ptr object for resource pointed to by _Other        this->_Resetw(_Other);    }    template<class _Ty2>    weak_ptr(const weak_ptr<_Ty2>& _Other,        typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,        void *>::type * = 0)    {    // construct weak_ptr object for resource pointed to by _Other        this->_Resetw(_Other);    }    ~weak_ptr()    {    // release resource        this->_Decwref();    }    weak_ptr& operator=(const weak_ptr& _Right)    {    // assign from _Right        this->_Resetw(_Right);        return (*this);    }    template<class _Ty2>    weak_ptr& operator=(const weak_ptr<_Ty2>& _Right)    {    // assign from _Right        this->_Resetw(_Right);        return (*this);    }    template<class _Ty2>    weak_ptr& operator=(shared_ptr<_Ty2>& _Right)    {    // assign from _Right        this->_Resetw(_Right);        return (*this);    }    void reset()    {    // release resource, convert to null weak_ptr object        this->_Resetw();    }    void swap(weak_ptr& _Other)    {    // swap pointers        this->_Swap(_Other);    }    bool expired() const    {    // return true if resource no longer exists        return (this->_Expired());    }    shared_ptr<_Ty> lock() const    {    // convert to shared_ptr        return (shared_ptr<_Elem>(*this, false));    }};

 

C++智能指针 weak_ptr