Observer Pattern Via Boost Signal2

Question

So, I've read the docs for Boost.Signal2 and I have done a bit of googling and I just haven't quite found what I needed. What I have is a controller and a view concept. The Controller will be sending data to the View for it to render. What I want is my controller to call Controller::Update and trigger the OnUpdate function in the view.

• The controller and view should be disjoint
• Signals on the Controller can be emitted to execute Slots in the View

Here is code I have tried so far:

class Listener {
public:
    virtual void OnUpdate() {};
};

class View :Listener
{
public:
    View(void);
    ~View(void);
    virtual void OnUpdate() override;
};

void View::OnUpdate()
{
    std::cout << "Updating in View";
}

class Controller
{
public:
    Controller(void);
    ~Controller(void);
    void Update();
};

Controller::Controller(void)
{
    // Signal with no arguments and a void return value
    boost::signals2::signal<void ()> sig;
    sig.connect(boost::bind(&Listener::OnUpdate, this, _1));
    // Call all of the slots
    sig();
    system("pause");
}

This does not compile. I get error C2825: 'F': must be a class or namespace when followed by '::', but this is just because I'm using bind incorrectly.

Does anybody know how I could achieve what I want using signals/slots from boost?

Answer 1

There are quite a number of misconceptions here. I recommend you start simpler.

• the Listener base class probably needs a virtual destructor
• you cannot bind Listener::OnUpdate to this inside the Controller class because Controller is not derived from Listener
• You need to derive publicly from Listener
• there is no argument, so you need to pass zero placeholders (_1 was out of place)

Here's a simple fixed-up sample

Live On Coliru

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

class Listener {
public:
    virtual ~Listener() = default;
    virtual void OnUpdate() = 0;
};

class View : public Listener
{
public:
    View() = default;
    ~View() = default;
    virtual void OnUpdate() override {
        std::cout << "Updating in View\n";
    }
};

class Controller
{
    boost::signals2::signal<void ()> sig;
public:
    Controller() {
    }

    void subscribe(Listener& listener) {
        // Signal with no arguments and a void return value
        sig.connect(boost::bind(&Listener::OnUpdate, &listener));
    }

    void DoWork() const {
        // Call all of the slots
        sig();
    }

    void Update();
};

int main() {

    View l1, l2;
    Controller c;

    c.subscribe(l1);

    std::cout << "One subscribed:\n";
    c.DoWork();

    c.subscribe(l2);

    std::cout << "\nBoth subscribed:\n";
    c.DoWork();
}

Which prints:

One subscribed:
Updating in View

Both subscribed:
Updating in View
Updating in View

Computer, Simplify: Now C++ style

Perhaps a more compelling example in C++ would be:

Live On Coliru

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

struct View {
    void OnUpdate() { std::cout << "Updating in View\n"; }
};

class Controller {
    using UpdateHandler = boost::signals2::signal<void()>;
    UpdateHandler sig;

  public:
    Controller() {}

    void subscribe(UpdateHandler::slot_type handler) { sig.connect(handler); }
    void DoWork() const { sig(); }
    void Update();
};

int main() {

    View l1;
    Controller c;
    c.subscribe(std::bind(&View::OnUpdate, &l1));
    c.subscribe([] { std::cout << "Or we can attach a random action\n"; });

    c.DoWork();
}

Which prints

Updating in View
Or we can attach a random action