C++ boost：：与弱\u ptr共享\u ptr周期中断

我目前的处境如下：

struct A {  
  shared_ptr<B> b;  
};  
struct B {  
  shared_ptr<A> a;  
};

//...
shared_ptr<A> a(new A());
shared_ptr<B> b(new B());  
a->b(b);
b->a(a);

结构A{ 共享ptr b； }; 结构B{ 共享ptr a； }; //... 共享的ptr a（新的a（））； 共享_ptr b（新b（））； a->b（b）； b->a（a）； 我知道这行不通，因为引用会继续指向对方。我还被告知，

弱ptr

解决了这个问题

---

但是，

弱\u ptr

没有get或

->

重载。我听说有人提到“使用

lock（）

”，但有人能给出如何正确执行此操作的代码示例吗？

您是否查看了上的boost参考

shared_ptr p（新int（5））；
弱ptr q（p）；
//一段时间以后
if（共享的\u ptr r=q.lock（））
{
//使用*r
}

这样做的目的是锁定

弱\u ptr

，从而获得一个

共享的\u ptr

，该共享的\u ptr包含操作符

首先检查获取的指针是否指向某个对象。

弱\u ptr

不确定资源的使用寿命，但它允许您检查资源是否已被销毁。

\35;包括
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

struct B;

struct A
{
    boost::weak_ptr< B > b;
};

struct B
{
    boost::weak_ptr< A > a;
};

int
main()
{
    boost::shared_ptr<A> a(new A());
    boost::shared_ptr<B> b(new B());
    a->b = b;
    b->a = a; 
    boost::shared_ptr<A> another_a( b->a.lock() );
}

#包括
结构B；
结构A
{
boost：：弱ptrB；
};
结构B
{
boost：：弱ptrA；
};
int
main（）
{
boost:：shared_ptr a（新的a（））；
boost:：shared_ptr b（新的b（））；
a->b=b；
b->a=a；
boost:：shared_ptr另一个_a（b->a.lock（））；
}

您可以使用

弱\u ptr:：lock

将

弱\u ptr

升级为

共享\u ptr

，现在开始

^^^^^例子就在这里^^^^^^

---

该死

我认为这里更大的问题是所有权不明确。你最好决定

A

是封装

B

还是反过来封装。如果这是不可能的，那么您最好引入另一个

类C

，它同时拥有

A

和

B

假设

A

拥有

B

，您可以编写：

classs B;

classs A
{
private:
    boost::scoped_ptr<B> b_;
public:
    A() : b_(new B()) {}
}

class B
{
private:
    A* a_;
public:
    B(A* a) : a_(a) {}
}

B类；
A类
{
私人：
boost：：作用域的ptr b；
公众：
A（）：b_（新b（））{}
}
B类
{
私人：
A*A；
公众：
B（A*A）：A_uz（A）{}
}

等等。您甚至可以通过将B设为局部变量或在析构函数中手动删除它来摆脱

作用域\u ptr

在标题为“.”的部分中，政府有更多的话要说

---

Hth

1，我看到某人引用谷歌C++风格指南时，我几乎哽咽了…但这一次我同意他们的观点，明确的所有权比到处散布

shared\ptr

更可取。谢谢你的+1！但我很好奇你对谷歌C++风格指南的看法。有什么特别的原因让你觉得它有点窒息吗？+1“这里更大的问题是所有权不明确”是的；你需要首先考虑所有权，只有当你了解对象之间的关系时，你才可以选择使用智能指针。-1在链接到文档时是有帮助的，所以如果链接死了，答案应该对未来的访问者有用。这个答案除了一个链接外，没有提供任何信息。对OP的态度不好

classs B;

classs A
{
private:
    boost::scoped_ptr<B> b_;
public:
    A() : b_(new B()) {}
}

class B
{
private:
    A* a_;
public:
    B(A* a) : a_(a) {}
}