Управление общим ресурсом с использованием std :: weak_ptr

У меня нет большого опыта в общих указателях, но да, это кажется очень подходящим использованием weak_ptr,

В этом случае вы просто раздражены тем, что:

1. Вы хотели бы использовать InputConsumerнепосредственно как члены ModelControllerс, так как это тривиальные отношения собственности.
2. Вы вынуждены использовать shared_ptr чтобы заставить его работать с weak_ptr,

Я думаю, что это решается с помощью shared_ptr как псевдоним члена объекта. В соответствии с C ++. Ком:

Кроме того, объекты shared_ptr могут совместно использовать указатель
в то же время указывая на другой объект. Эта способность
известный как псевдонимы (см. конструкторы), и обычно используется для указания на
объекты-участники, в то время как владеют объектом, которому они принадлежат.

Я никогда не делал это сам, но это, кажется, адаптировано к вашей ситуации:

• Есть InputConsumerс членами ModelControllers
• Иметь псевдоним shared_ptr для каждого из них
• Ссылка на них в InputSender с помощью weak_ptrs

РЕДАКТИРОВАТЬ

Вот полный минимальный рабочий пример:

#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 Deleter, который на самом деле ничего не удаляет.

Остальная часть кода должна быть понятна с комментариями.