c++ - 使用 std::weak_ptr 共享资源所有权

Question

我想知道如何(使用 C++11 并希望使用向后(boost 或 TR1)兼容的智能指针类型)实现:

一个类实例 (ModelController) 拥有一个资源 (InputConsumer)，而另一个组件 (InputSender，在本例中是一个单例) 可以访问它。

模型是 InputSender 包含对 InputConsumers 的引用列表，其中会有很多。

ModelController 可能没有、一个或多个 InputConsumers，并且可能有多个 ModelController。 InputSender 不知道。

这是一个很好的方法:InputSender 跟踪分配给它的 InputConsumers 的方法，这样它可以自己找出个人 InputConsumers 是否有效。

在我看来 weak_ptr 非常适合这个目的，因为它们的使用需要检查这个条件。

如果 InputSender 停止跟踪它的任何 weak_ptr 引用，没有什么不好的事情发生，相应的 InputConsumer 只会经历 radio 静默。

如果一个 ModelController 被删除，或者如果一个 ModelController 删除它的一些 InputConsumer，任何 InputSender已经向他们注册的 s 将在他们下次尝试访问它们时识别它们不再存在，并且可以清理，而无需发送消息或执行任何操作。

所以问题是，这种情况是否适合使用 shared_ptr 和 weak_ptr？我想知道 shared_ptr 是否完全合适，因为 InputConsumer 在概念上由它们的 ModelController 拥有，所以它们应该是成员变量。我不知道 ModelController 只通过 shared_ptr 管理它们有多大意义。我不知道 unique_ptr 是否与 weak_ptr 一起工作。我是否应该只管理 ModelController 的 ctor/dtor 中的 shared_ptr？

这可能还有一个众所周知的(对我来说不是!)设计模式，所以如果有人知道这样的事情请告诉我。

Answer 1

我在共享指针方面没有很多专业知识，但是，这似乎是 weak_ptr 的一个非常合适的用法。 .

在这种情况下，您只是感到恼火:

1. 您想使用 InputConsumer直接作为ModelController的成员s，因为它是一种微不足道的所有权关系。
2. 您被迫使用 shared_ptr使其与 weak_ptr 一起工作.

我认为这可以通过使用 shared_ptr 来解决作为成员对象的别名。根据C++.com :

Additionally, shared_ptr objects can share ownership over a pointer while at the same time pointing to another object. This ability is known as aliasing (see constructors), and is commonly used to point to member objects while owning the object they belong to.

我自己从来没有做过，但这似乎适合你的情况:

• 有InputConsumer ModelController的成员小号
• 有一个别名shared_ptr对于他们每个人
• 在 InputSender 中引用它们使用 weak_ptr小号

编辑

这是一个完整的最小工作示例:

#include <iostream>
#include <memory>

using namespace std;

// A class to try our smart pointers on
struct Foo 
{
    Foo() { cout << "constructing Foo\n"; }
    ~Foo() { cout << "destructing Foo\n"; }
};

// A class that owns some Foo as members
struct Owner
{
    // The actual members
    Foo foo1;
    Foo foo2;

    // A fake shared pointer whose purpose is:
    //   1) to be of type shared_ptr<>
    //   2) to have the same lifetime as foo1 and foo2
    shared_ptr<Owner> self;

    // A fake deleter that actually deletes nothing 
    struct Deleter
    {
        void operator() (Owner *) { cout << "pretend to delete Owner\n"; }
    };

    Owner() : self(this, Deleter()) { cout << "constructing Owner\n"; }
    ~Owner()                        { cout << "destructing Owner\n"; }
};

// A class that holds a reference to a Foo
struct Observer
{
    // A reference to a Foo, as a weak pointer
    weak_ptr<Foo> foo_ptr;

    Observer(const shared_ptr<Foo> & foo_ptr) : foo_ptr(foo_ptr)
    {
        cout << "constructing Observer\n";
    }
    ~Observer() { cout << "destructing Observer\n"; }

    void check()
    {
        if(foo_ptr.expired())
            cout << "foo expired\n";
        else
            cout << "foo still exists\n";
    }   
};  

int main()
{
    // Create Owner, and hence foo1 and foo2
    Owner * owner = new Owner;

    // Create an observer, passing an alias of &(owner->foo1) to ctor
    Observer observer(shared_ptr<Foo>(owner->self, &(owner->foo1)));

    // Try to access owner->foo1 from observer
    observer.check();
    delete owner;
    observer.check();

    return 0;
}

它打印:

constructing Foo
constructing Foo
constructing Owner
constructing Observer
foo still exists
destructing Owner
pretend to delete Owner
destructing Foo
destructing Foo
foo expired
destructing Observer

棘手的部分是能够创建一个 weak_ptr至 owner->foo1 (与 foo2 相同)。为此，我们首先需要一个 shared_ptr那是 owner->foo1 的别名.这只能通过以下方式完成:

shared_ptr<Foo> alias(other_shared_ptr, &(owner->foo1));

哪里other_shared_ptr是 shared_ptr<T>其生命周期至少与 owner->foo1 中的一个一样长.为此，使用 shared_ptr<T>这也是 owner 的成员是个好主意，因为它确保生命周期相同。最后，我们需要一个有效的非空指针给它，因为我们不想在堆上创建任何东西，所以我们必须使用一个现有的对象。 this是一个很好的候选者，因为我们知道它是有效的并且只有在其成员被销毁后才会被销毁。因此我们的 other_shared_ptr例如:

shared_ptr<Owner> self(this);

然而，这意味着当self超出范围，即在 owner 的销毁期间, 它会调用 delete this .我们不希望发生这种删除，否则this将被删除两次(这是未定义的行为，实际上是段错误)。因此我们也提供给 self 的构造函数一个实际上不删除任何东西的删除器。

代码的其余部分应该带有注释，不言自明。