boost::shared_ptr 的适当用途？

Question

这里有一个关于boost::shared_ptr的问题：

我有 3 个课程。

A 是某种 Main 类，负责管理所有内容。

B 是一个类，它只具有执行某些工作的功能。

Dispatcher 只是一个封装了一个单独线程的类，它从该线程中Bdone 的 Instaces 获取工作。

所以它有点像这样工作：A 有一个Dispatcher 的实例。现在偶尔A 会生成B 的实例并将其传递给调度程序。

重要的是，B 完成后需要调用A::callback()。这就是为什么B 在其构造函数中获得对 A 的引用（参见下面的代码）

A.hpp

class A : public boost::enable_shared_from_this<A>
{
public:
    A();
    void sendB();
    void callback();
private:
    Dispatcher m_Dispatcher;
};

B.hpp

class B
{
public:
    B(boost::shared_ptr<A> ptr);
    boost::shared_ptr<A> m_PointerToA;
 /* Some other functions */
};

Dispatcher.hpp

class Dispatcher
{
public:
     void run();
     void dispatch(boost::shared_ptr<B> b);
private:
     void doWork();
     boost::thread m_Thread;  
};

A.cpp

A::A()
{
    m_Dispatcher.run();
}
void A::sendB()
{
    boost::shared_ptr ptr_B;
    ptr_B.reset(new B(this->shared_from_this);
    m_Dispatcher.dispatch(ptr_B);
}

B.cpp

B::B(boost::shared_ptr<A> ptr) :
    : m_PointerToA(ptr)
{
}

main_example.cpp

int main()
{
     A instanceA;
     while(true)
     {
          instanceA.sendB();
          /* Do some other stuff */
     }
     return 0;
}

所以我的问题是：

为此目的使用 boost::shared_ptr 是否合理？

我不确定shared_ptr 是否适合去这里。我的问题是，当我从B 调用构造函数并将this 指针传递给它时，我不知道究竟会发生什么。现在根据shared_ptr，我假设m_PointerToA 拥有A 的所有权。但这意味着当Dispatcher 中的工作完成并且我的B 实例被删除时，它也会删除对m_PointerToA 的引用，这实际上意味着它会杀死对象本身，尽管事实上存在一个实际的主循环中A 的实例。

更新：

添加了一些代码并更新了问题本身以使其更加清晰。

Answer 1

这个设计没有什么特别的问题。但是我更愿意使用boost::function<> 和boost::bind。它为回调提供了更好的灵活性，并且不会将 B 与 A 紧密联系在一起。当然，您仍然必须对通常的线程警告有所不同。

Answer 2

是的，只复制/分配shared_ptr 是可以的，它只会增加引用计数。

在您的示例中，shared_from_this() 将从 weak_ptr 中创建一个（此处：临时）shared_ptr，该 this 持有（参考计数 1），因此当您分配/复制构造 m_PointerToA ，在ctor返回之前引用计数将暂时增加到2并且临时对象将被销毁，引用计数再次减少到1（shared_ptr“知道”你的B对象中的一个实例）。

所以，是的，如果 B 被删除，在这种情况下它将破坏 A（因为引用计数下降到 0）。

您的关心

这意味着如果我的 B 实例被删除，它也会删除 m_PointerToA ，这也会杀死我的 A 实例。当然，我原来的 A 实例在别处。

仅表明如果您计划/需要/打算保留指向 A 实例的指针以供进一步使用，您也应该使用 shared_ptr 而不是原始指针。如果您可以控制A 的界面，最简单的方法是named constructor，如下所示：

class A : public boost::enable_shared_from_this<A> {
    public:
        static boost::shared_ptr<A> create();

        void initClassB();
        // ....
    private:
        A();
        A( const A & other );
        A& operator=( const A & rhs );

};

boost::shared_ptr<A> A::create() {
    return boost::shared_ptr<A>( new A() );
}

那么，即使您的B 实例被删除，A 的实例仍然会存在，因为shared_ptr 的引用计数仍然（至少）为 1。