当前位置：首页>前端>正文

weak_ptr作用

前端2024-10-23 09:16:55

weak_ptr的用处_weak_ptr的作用_kyowill的博客-CSDN博客

循环引用问题

#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
};

class B {
public:
    std::shared_ptr<A> a_ptr;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b_ptr = b;
    b->a_ptr = a;

    return 0;
}

循环引用示意图

见上图，当 main 函数结束时，a 和 b 这两个共享指针会被销毁，但是因为 a->b_ptr 和 b->a_ptr 的共享指针引用仍然存在，所以 A 和 B 对象共享指针引用计数都从2变为1，于是这两个对象都没有正常销毁

为了解决循环引用的问题，可以使用 std::weak_ptr，它可以避免形成循环引用，因为** std::weak_ptr 不会增加引用计数**。只有当需要使用对象时，可以将 std::weak_ptr 转换成 std::shared_ptr，如果对象已经被销毁，则转换会失败。

以下是使用 std::weak_ptr 改进上述代码的示例：

#include <memory>

class B; // Forward declaration

class A {
public:
    std::shared_ptr<B> b_ptr;
};

class B {
public:
    std::weak_ptr<A> a_ptr; // Using weak_ptr here
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b_ptr = b;
    b->a_ptr = a;

    return 0;
}

这样，A 和 B 之间的循环引用就不会造成内存泄漏。

具体说明 `std::weak_ptr` 转换成 `std::shared_ptr`然后使用？

当你需要使用 std::weak_ptr 指向的对象时，你可以通过调用 std::weak_ptr 的 lock() 成员函数来尝试将它转换为一个有效的 std::shared_ptr。这个操作会检查所指向的对象是否还存在，如果存在，就会返回一个指向该对象的有效 std::shared_ptr，否则返回一个空的 std::shared_ptr。

在你的代码中，如果你需要使用 B 对象所指向的 A 对象，你可以这样做：

#include <memory>

class B; // Forward declaration

class A {
public:
    std::shared_ptr<B> b_ptr;
};

class B {
public:
    std::weak_ptr<A> a_ptr; // Using weak_ptr here
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b_ptr = b;
    b->a_ptr = a;

    // Using weak_ptr to access the object
    std::shared_ptr<A> a_from_b = b->a_ptr.lock();
    if (a_from_b) {
        // You can safely use a_from_b here
    } else {
        // The object has been destroyed
    }

    return 0;
}

在上面的代码中，通过调用 b->a_ptr.lock()，你可以获得一个指向 A 对象的 std::shared_ptr，如果 A 对象仍然存在的话。如果 A 对象已经被销毁，a_from_b 将会是一个空的 std::shared_ptr。这样你就可以在使用对象之前检查它是否还存在，避免悬空指针的问题。

注意

虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在能预见会出现循环引用的情况下才能使用，即这个仅仅是一种编译期的解决方案，如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。

具体说明

weak_ptr是为配合shared_ptr而引入的一种智能指针，它更像是shared_ptr的一个助手，而不是一个智能指针。它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr被设计为与shared_ptr协同工作，可以从一个shared_ptr或者另外一个weak_ptr对象构造，获得资源的观测权限。但weak_ptr没有共享资源，它的构造不会引入指针引用技术的增加，同样，weak_ptr析构时也不会导致引用技术减少，它只是一个静静的观察着。weak_ptr的一个很重要作用是：打破循环引用。

让我们一步步来分析循环引用问题。

SharedPtrNode

#ifndef SHAREPTRNODE_H_
#define SHAREPTRNODE_H_

#include <iostream>
using  namespace  std;

#include <boost/smart_ptr.hpp>
using  namespace  boost;

class  SharePtrNode {
public :
   int   spNodeId;
   SharePtrNode();
   SharePtrNode( int  nId);
   virtual  ~SharePtrNode();

   typedef  boost::shared_ptr<SharePtrNode> ptr_type;
   ptr_type next;
};

#endif /* SHAREPTRNODE_H_ */

    
#include "SharePtrNode.h"
#include <iomanip>  //for setw and setfill
 
SharePtrNode::SharePtrNode():SharePtrNode(0) {
     // TODO Auto-generated constructor stub
 
}
 
SharePtrNode::SharePtrNode( int  nId)
{
     spNodeId = nId;
     cout <<  "SharePtrNode, [spNodeId:" 
                     << setw(4) << setfill( '0' ) << spNodeId <<  "]"  << endl;
}
 
SharePtrNode::~SharePtrNode() {
     // TODO Auto-generated destructor stub
     cout <<  "~SharePtrNode, [spNodeId:" 
                     << setw(4) << setfill( '0' ) << spNodeId <<  "]"  << endl;
}

一个SharePtrNode对象包含一个自身id(spNodeId)和一个指针：ptr_type next。这个指针是一个shared_ptr类型的指针。基于上述SharePtrNode类，我们构建一个简单的使用场景：动态创建两个SharePtrNode对象。

void  Case03_ShareAndWeakPtrLoopRef_1()
{
     auto  sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
     auto  sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
}

由于是通过shared_ptr管理的两个对象，因此，两个对象会在函数退出时自动销毁，且销毁的顺序与创建的顺序相反。


——> Case03_ShareAndWeakPtrLoopRef_1

SharePtrNode, [spNodeId:0001]

SharePtrNode, [spNodeId:0002]

~SharePtrNode, [spNodeId:0002]

~SharePtrNode, [spNodeId:0001]

这种场景下一切似乎都非常合理。
引用示意图如下：

那如果对case场景做进一步补充：将sharedPtrNode1的next指针指向sharedPtrNode2，会产生什么结果呢？

    
void  Case03_ShareAndWeakPtrLoopRef_2()
{
     auto  sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
     auto  sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
 
         sharedPtrNode1->next = sharedPtrNode2;
}

这个时候，会有什么输出出现呢？


——> Case03_ShareAndWeakPtrLoopRef_2

SharePtrNode, [spNodeId:0001]

SharePtrNode, [spNodeId:0002]

~SharePtrNode, [spNodeId:0001]

~SharePtrNode, [spNodeId:0002]

顺序变了，为什么会这样？因为在执行sharedPtrNode1->next = sharedPtrNode2;的时候实际上SharedPtrNode2的引用计数已经从1增加到了2，当函数退出时，首先SharedPtrNode2先析构，此时SharedPtrNode2的引用技术从2减回到1，因为不到0，因此实际的SharedPtrNode2此时还不能销毁，析构函数没有被调用。而此后SharedPtrNode1进行析构，此时因为SharedPtrNode1的引用计数原本只有1，此时降低到0，因此SharedPtrNode1的析构函数被调用：“~SharePtrNode, [spNodeId:0001]”，在SharedPtrNode1进行析构的时候，SharedPtrNode1的成员变量sharedPtrNode1->next也会一并析构，此时由于next指向的节点引用计数已经是1了，析构的时候，变成0，因此执行最终指向节点的SharePtrNode2的析构，因此“~SharePtrNode, [spNodeId:0002]”输出。这也就是为什么node2在node1之后析构的原因。
引用示意图如下：

共享指针就是用来管理对象的生命周期的，对象的是否析构要看指向该对象的共享指针的引用计数是否降为0，为0则析构，否则不析构。（注意区分共享指针对象的析构≠共享指针指向对象的析构）
析构时，指向B的共享指针对象b先析构，此时指向B的共享指针引用计数由2变为1，但不是0，所以B对象的析构函数未被调用
而后，指向A的共享指针对象a先析构，此时指向A的共享指针引用计数由1变为0，于是A的析构函数被调用
由于对象A的析构，其成员——指向B对象的共享指针对象a被析构，此时B的共享指针引用计数由1变为0，这时B的析构函数被调用
这也就解释了上述的析构函数调用顺序问题

在进一步构建一个更为复杂一点的场景：再sharedPtrNode2的next指针指向sharedPtrNode1，会产生什么结果呢？

void  Case03_ShareAndWeakPtrLoopRef_3()
{
     auto  sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
     auto  sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
 
         sharedPtrNode1->next = sharedPtrNode2;
         sharedPtrNode2->next = sharedPtrNode1;
}

我们可以看到，此时的输出结果如下：


——> Case03_ShareAndWeakPtrLoopRef_3

SharePtrNode, [spNodeId:0001]

SharePtrNode, [spNodeId:0002]

两个对象都值进行了初始化，而没有进行析构！
这里可参见开头的解释。

查看全文

https://www.xamrdz.com/web/22g1997363.html

循环引用问题

具体说明 std::weak_ptr 转换成 std::shared_ptr然后使用？

注意

具体说明

相关文章：

具体说明 `std::weak_ptr` 转换成 `std::shared_ptr`然后使用？