Ретрансляция сигнала с помощью boost.signals2

Две вещи:

• Когда вы привязываетесь к boost::ref(obj), вы заставляете выражение привязки содержать ссылку на параметр функции, который выходит за рамки при выходе из register_callback. (См. Копирует ли boost::bind() параметры по ссылке или по значению?)

  Просто привяжите к самому указателю, что заставляет выражение привязки содержать копию самого указателя.

• При регистрации обратных вызовов важно помнить о проблемах жизненного цикла. Как правило, вы должны отменить регистрацию перед уничтожением любого связанного объекта в слоте сигнала.

  В вашем примере этого на самом деле не происходит, потому что все подключенные слоты существуют в объектах-членах. Это означает, что слоты уничтожаются до того, как внешние объекты исчезнут.

  Однако, если что-то копируется/перемещается, это ломается. Обычный способ борьбы с этим — использовать scoped_connections.

Позвольте мне показать мои предложения в два этапа:

Упрощение: раннее связывание, Signals2 печатает Erasure за вас

Нет необходимости в шаблоне register_callback, потому что вы печатаете-стираете тип объекта T немедленно, используя bind и пустой слот сигнала.

Итак, вместо этого заставьте его принимать произвольный nullary и выполнять привязку в вызывающем объекте? На самом деле, лучше использовать лямбду у вызывающего абонента.

template <class F> void register_callback(F&& f) {
    sig_inner_.connect(std::forward<F>(f));
}

А потом

mid() { inner_obj.register_callback([this] { handle_sig_mid(); }); }

Время жизни и сигналы2: связи

Вместо того, чтобы использовать тяжеловесный вариант и везде использовать enable_shared_from_this() с динамическим размещением, используйте возможности библиотеки: http://www.boost.org/doc/libs/1_65_1/doc/html/boost/signals2/scoped_connection.html

Примечание В вашем примере об использовании shared_from_this() не может быть и речи, поскольку оно недопустимо внутри конструктора.

Мое предложение:

template <class F> boost::signals2::scoped_connection register_callback(F&& f) {
    return sig_inner_.connect(std::forward<F>(f));
}

А потом

mid() { _connection = inner_obj.register_callback([this] { handle_sig_mid(); }); }

Сделать _connection участником:

boost::signals2::scoped_connection _connection;

Таким образом, слоты отключаются при уничтожении содержащего их класса.

Полная демонстрация

Жить на Coliru

#include <boost/bind.hpp>
#include <boost/signals2.hpp>
#include <iostream>

class inner {
  public:
    template <class F> boost::signals2::scoped_connection register_callback(F&& f) {
        return sig_inner_.connect(std::forward<F>(f));
    }

    void trigger() {
        std::cout << "inner" << std::endl;
        sig_inner_();
    }

  private:
    boost::signals2::signal<void()> sig_inner_;
};

class mid {
  public:
    mid() { _connection = inner_obj.register_callback([this] { handle_sig_mid(); }); }

    template <class F> boost::signals2::scoped_connection register_callback(F&& f) {
        return sig_mid_.connect(std::forward<F>(f));
    }

    void trigger() { sig_mid_(); }
    void inner_trigger() { inner_obj.trigger(); }
    void handle_sig_mid() {
        std::cout << "mid" << std::endl;
        trigger();
    }

  private:
    boost::signals2::scoped_connection _connection;
    boost::signals2::signal<void()> sig_mid_;
    inner inner_obj;
};

class outer {
  public:
    outer() { _connection = mid_obj.register_callback([this] { handle_sig_outer(); }); }
    void inner_trigger() { mid_obj.inner_trigger(); }

  private:
    boost::signals2::scoped_connection _connection;
    mid mid_obj;
    void handle_sig_outer() { std::cout << "outer" << std::endl; }
};

int main() {
    outer outer_obj;
    outer_obj.inner_trigger();
    return 0;
}

Отпечатки

inner
mid
outer

Везде, где у вас есть обработчик для вызова, передайте ему экземпляр std::shared_ptr текущего экземпляра класса. Этого можно добиться путем публичного наследования enable_shared_from_this. Таким образом, ваш экземпляр mid будет поддерживаться до тех пор, пока обработчик не завершит работу.

class mid : public std::enable_shared_from_this<mid>
{
    mid()
    {
        inner_obj.register_callback<mid>(&mid::handle_sig_mid, shared_from_this());
    }

    //...
};