Aprendiendo c ++ y tratando de familiarizarse con algunos patrones. lossignal2 doc Claramente tiene una gran variedad de cosas que puedo hacer con ranuras y señales. Lo que no entiendo es para qué tipo de aplicaciones (casos de uso) debo usar.

Estoy pensando en la forma en que una máquina de estado envía eventos de cambio. Si viene de un fondo de tipo dinámico (C #, Java, etc.), usaría un despachador de eventos o una referencia estática o una devolución de llamada.

¿Hay dificultades en c ++ con el uso de devoluciones de llamada entre clases? ¿Es eso esencialmentepor qué signal2 existe?

Uno de los casos de ejemplo es un documento / vista. ¿Cómo se adapta mejor este patrón que decir, usar un vector de funciones y llamar a cada una en un bucle, o decir una lambda que llame a los cambios de estado en las instancias de clase de escucha registradas?

class Document
{
public:
    typedef boost::signals2::signal<void ()>  signal_t;

public:
    Document()
    {}

    /* Connect a slot to the signal which will be emitted whenever
      text is appended to the document. */
    boost::signals2::connection connect(const signal_t::slot_type &subscriber)
    {
        return m_sig.connect(subscriber);
    }

    void append(const char* s)
    {
        m_text += s;
        m_sig();
    }

    const std::string& getText() const
    {
        return m_text;
    }

private:
    signal_t    m_sig;
    std::string m_text;
};

y

class TextView
{
public:
    TextView(Document& doc): m_document(doc)
    {
        m_connection = m_document.connect(boost::bind(&TextView::refresh, this));
    }

    ~TextView()
    {
        m_connection.disconnect();
    }

    void refresh() const
    {
        std::cout << "TextView: " << m_document.getText() << std::endl;
    }
private:
    Document&               m_document;
    boost::signals2::connection  m_connection;
};