Aprendendo c ++ e tentando se familiarizar com alguns padrões. osinais2 doc claramente tem uma vasta gama de coisas que eu posso fazer com slots e sinais. O que eu não entendo é para quais tipos de aplicativos (casos de uso) eu deveria usá-los.

Estou pensando nas linhas de uma máquina de estado despachando eventos de mudança. Vindo de um fundo digitado dinamicamente (C #, Java etc) você usaria um despachante de evento ou uma referência estática ou um retorno de chamada.

Há dificuldades em c ++ com o uso de retornos de chamadas entre classes? Isso é essencialmenteporque sinais2 existe?

Um para os casos de exemplo é um documento / visão. Como esse padrão é mais adequado do que dizer, usando um vetor de funções e chamando cada um em um loop, ou digamos um lambda que chame mudanças de estado em instâncias de classes de escuta 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;
};

e

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;
};