C++ signal callback (like javascript)

Question

I am new to C++, and I'm trying to port some javascript scripts while learning the new language.

I am trying to find solutions to use callbacks like javascript, especially like the js-signals library

Below is a script in javascript. Can it be converted to C++? How? If no, what is the best solution?

Javascript

var ns = {
   _callback: null,
   setUpdate: function(callback) {
      ns._callback = callback;
   },
  update: function() {
      // do some default things
      ns._callback();
   }
};
ns.setUpdate(function() {
   console.log("I'm Changed"); // will be: std::cout << "I'm Changed\n";
});

C++

namespace ns {
   // ??
};
// ns::setUpdate(??);

Yes, you can do callbacks in c++. I think the closest c++ equivalent to your JS code (I don't know anything about JS, so I'm only guessing) would be to store a lambda in an `std::function` member variable. — MikeMB, May 15 '16 at 00:38
Search for "function pointers c++" and "lambda expressions c++"....that will get you started.....there is a lot to process with that though — DarthRubik, May 15 '16 at 00:54

score 3 · Accepted Answer · edited May 23 '17 at 12:22

3

You can use a function pointer, like so:

#include <cstdio>
namespace ns {
  // defines a type named Callback that is a pointer
  // to a function that takes void and returns void
  typedef void (*Callback)();
  Callback _callback;

  void setUpdate( Callback cb) {
    _callback = cb;
  }
  void update() {
    _callback();
  }
}

void MyUpdate() {
  printf("hello from callback\n");
}

int main(int argc, char* argv[]) {

  ns::setUpdate(MyUpdate);
  ns::update();
}

output:

hello from callback

See also: Typedef function pointer?

edited May 23 '17 at 12:22

Community

1
1

answered May 15 '16 at 00:58

eyeApps LLC

643
4
10

Thanks a lot. Can you explain what this does? "typedef void (*Callback)();" – Liakos May 15 '16 at 12:04
added a comment to the code to explain..the link I had in the original post also explains more. – eyeApps LLC May 15 '16 at 19:08

score 1 · Answer 2 · answered May 15 '16 at 00:55

I wouldn't use a namespace like that. A class is probably a better fit for something like this:

#include <iostream>
#include <functional>

class MyThing
{
public:
    MyThing() {}
    MyThing(const std::function<void()>& callback) : callback_(callback) {}
    void setUpdate(const std::function<void()>& callback)
    {
        callback_ = callback;
    }

    void update()
    {
        std::cout << "Update called\n";
        if (callback_) {
            callback_();
        }
    }
private:
    std::function<void()> callback_;
};

int main()
{
    MyThing my_thing1; // callback_ is initially unset in this object
    my_thing1.update(); // no callback is called
    my_thing1.setUpdate([](){ std::cout << "I'm Changed 1\n"; });
    my_thing1.update(); // calls the lambda set in the previous line
    MyThing my_thing2([](){ std::cout << "I'm Changed 2\n"; });
    my_thing2.update(); // calls the lambda in the prevous line
}

This will output

Update called
Update called
I'm changed 1
Update called
I'm changed 2

score 0 · Answer 3 · answered Jun 04 '16 at 22:54

This is a nice way to port javascript js-signals library to c++:

#include <string>
#include <map>
#include <functional>

// You only need this Signal class
class Signal {

    // store all callbacks to a string map
    std::map<std::string, std::function<void()>> callbacks;

    // check if callback already exists. optional
    bool exists(std::string key) {
        if (callbacks.find(key) == callbacks.end()) {return false;}
        else {return true;}
    }

    public:
    void add(std::string key, std::function<void()> cb) {
        if (!exists(key)) {remove(key);}
        callbacks.insert(std::pair<std::string, std::function<void()>>(key, cb));
    }
    void remove(std::string key) {
        callbacks.erase(key);
    }
    void dispatch() {
        for (std::map<std::string, std::function<void()>>::iterator it = callbacks.begin(); it != callbacks.end(); it++) {
            callbacks[it->first]();
        }
    }

    // this destroys the signal
    void dispose() {
        callbacks.clear();
    }
};

int main() {
    // create a signal
    Signal* onFire = new Signal();

    // add some callbacks
    int a_variable = 10;
    onFire->add("a_sound_is_heard", [&]() {
        // some code when onFire.dispatch() happens
        std::cout << "i can use this variable too :) " << a_variable << std::endl;
        // you can also use the onFire variable
    });
    onFire->add("a_bullet_appears", [&]() {
        // some code again
    });

    // remove some callbacks (add a silencer for your gun)
    onFire->remove("a_sound_is_heard");

    // whenever you want, execute the event
    onFire->dispatch();

    // don't forget to delete the signal from memory
    onFire->dispose();
    delete onFire;

    return 0;
}

C++ signal callback (like javascript)

3 Answers3