相关疑难解决方法(0)

我在enable_shared_from_this阅读Boost.Asio示例时跑了过来,在阅读完文档之后,我仍然因为如何正确使用它而迷失了方向.有人可以给我一个例子和/或说明何时使用这个课程是有道理的.

class B;

class A
{
public:
    A ()
        : m_b(new B())
    {
    }

    shared_ptr<B> GimmeB ()
    {
        return m_b;
    }

private:
    shared_ptr<B> m_b;
};

假设B是一个在语义上不应该存在于A的生命周期之外的类,也就是说,B对于它自身存在完全没有意义.应该GimmeB退还shared_ptr<B>还是B*？

一般来说,完全避免在C++代码中使用原始指针代替智能指针是一种好习惯吗？

我认为shared_ptr只应该在有明确的转让或共享所有权的情况下使用,我认为在函数分配一些内存,用一些数据填充并返回它的情况下很少见,并且有理解在调用者和被调用者之间,前者现在对该数据"负责".

关于boost::shared_ptrs的陷阱有几个有趣的问题.在其中一个中,有一个有用的提示,以避免指向boost::shared_ptr<Base>和boost::shared_ptr<Derived>相同的类型对象,Derived因为它们使用不同的引用计数,并可能过早地破坏对象.

我的问题:是否安全兼得boost::shared_ptr<T>并boost::shared_ptr<const T>点型的同一个对象T,还是将导致同样的问题？

我目前正在整理一个严重依赖的应用程序,shared_ptr到目前为止一切看起来都很好 - 我已经完成了我的功课,对使用shared_ptrs 的一些陷阱非常了解.

最常见的问题之一shared_ptr是循环依赖 - 这些问题可以通过存储weak_ptr不影响链上对象生命周期的问题来解决.然而,我正在努力解决需要通过以下方式存储指向外部对象的指针weak_ptr- 我不确定它是否被禁止,气馁或是否安全.

下图描述了我的意思(黑色箭头表示shared_ptr;虚线表示weak_ptr):

替代文字http://img694.imageshack.us/img694/6628/sharedweakptr.png

• 父对象包含shared_ptr两个子节点,两个子节点都使用a指向父节点weak_ptr.
• 在第一个子节点的构造函数中,我通过父节点检索weak_ptr指向第二个子节点的指针并将其存储在本地.

代码如下所示:

#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/enable_shared_from_this.hpp>

class child;
class child2;
class parent;

class parent : public boost::enable_shared_from_this<parent>
{
public:
    void createChildren()
    {
        _child2 = boost::make_shared<child2>(shared_from_this());
        _child = boost::make_shared<child>(shared_from_this());
    }

    boost::shared_ptr<child> _child;
    boost::shared_ptr<child2> _child2;
};

class child
{
public: …

我有结构,让我们称他们为sn,看起来像:

struct sn {
    string name;
    vector<sn*> connected_to;
};

现在,假设我已经从0 - 9声明了connected_to向量; 我将sn A连接到sn B:

A.connected_to[0] = &B; 

我有一种感觉,我会以错误的方式解决这个问题.基本上我正在尝试做的是避免在我连接结构时复制结构...即:

struct sn {
    string name;
    vector<sn> connected_to;
};

// ... 

A.connected_to[0] = B; 

这复制了吗？更基本的问题当然是我不明白向量,指针和引用是如何真正深入工作的.

AFAIK,使用shared_ptr通常是不鼓励的,因为不小心使用它们会导致潜在的错误(除非您对重大利益和仔细检查设计有非常好的解释).

另一方面,Python对象似乎基本上是shared_ptrs(ref_count和垃圾收集).

我想知道是什么让它们在Python中很好地工作但在C++中有潜在危险.换句话说,Python和C++在处理shared_ptr时有什么区别,这使得在C++中不鼓励使用它们但不会在Python中引起类似的问题？

我知道,例如Python会自动检测对象之间的循环,以防止在C++中悬挂循环shared_ptrs导致的内存泄漏.

我有两种类型:A和B.'聪明'指向B和B'聪明'指向A.在主要范围内,我有一个指向A的智能指针.

class A;
class B;
typedef shared_ptr<A> pA;
typedef shared_ptr<B> pB;

class B {
public:
    B() {}
    pA a;
    virtual ~B() {cout << "delete b" << endl;}
};

class A {
public:
    A() : b(new B()) {}
    pB b;
    virtual ~A() {cout << "delete a" << endl;}
};

int main(int argc, char **argv)
{
    {
        pA pa(new A());
        pa->b->a = pa;
    }
    cout << "here" << endl;

}

我希望在范围的末尾删除这两个对象.没有任何对象被删除,因为A有两个指向自身的指针(一个在b中,一个在主勺中).

这是一个简单的例子.实际上我有两种以上的类型和更多的指针.可以想象一个大的对象结构指向彼此浮动在RAM中,只有一个指针从主范围指向这个结构.我希望在释放此指针后删除此结构.