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

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

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

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

Я думаю, что это решается использованием shared_ptr в качестве алиаса объекта-члена. Согласно C++.com:

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

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

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

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

Просто еще один полный рабочий фрагмент, показывающий динамику std::weak_ptr, возможно, может помочь немного больше. (Мне особенно понравилась эта семантика expired());

#include<iostream>
#include<memory>
#include<string>

class MessageProcessor{                
};

class Message{
public:

        Message(std::shared_ptr<MessageProcessor>  _msg_proc, int _id){
                proc_weak = std::weak_ptr<MessageProcessor>(_msg_proc);
                proc_shared = _msg_proc;
                id = _id;
        }

        std::weak_ptr<MessageProcessor> proc_weak;
        std::shared_ptr<MessageProcessor> proc_shared;        
        int id;
};

int main(){

        std::shared_ptr<MessageProcessor> proc(new MessageProcessor());

        Message msg(proc,1);

        // Here we have proc with 2 shared_ptr refs: 'proc' and 'msg.proc_shared'
        // As expected 'msg.proc_weak is not expired'
        if( !msg.proc_weak.expired() )
                std::cout << "1) proc_weak is not EXPIRED. proc.use_count() == " << proc.use_count() << std::endl;        

        // make one of shared_ptr ref, point to other place
        msg.proc_shared = std::shared_ptr<MessageProcessor>();        

        // there is still the 'proc' reference        
        if( !msg.proc_weak.expired() )
                std::cout << "2) proc_weak is not EXPIRED (yet). proc.use_count() == " << proc.use_count() << std::endl;

        // 'erase' the last reference
        proc = std::shared_ptr<MessageProcessor>(); 

        // Finally... There is no more refs in shared_pointer!
        if( msg.proc_weak.expired() )
                std::cout << "3) proc_weak has EXPIRED. proc.use_count() == " << proc.use_count() << std::endl;

        return 0; 
}