C++ Member function as a callback

Question

I'm using a static class called websocket which listens on a websocket (hence the name) and calls a callback function once data is received. I created the following declarations

typedef int (*cb)(Json::Value &json);

static void websocket::init();
static void websocket::listen(cb callback, const char* address);

I also have a class called app which should contain the callback as a member function, because it is using a member property connecting to the database:

int app::callback(Json::Value& json)
{
    this->db->insert(json);
};

I'm calling the websocket::listen() function inside app like this:

void app::start()
{
    websocket::listen(std::mem_fn(&app::callback), this->path);
}

I get an error saying error: cannot convert 'std::_Mem_fn<int (app::*)(Json::Value&)>' to 'cb' {aka 'int (*)(Json::Value&)'}. To be able to keep the code as generic as possible so that I can call websocket::listen(); with other callbacks as well, I don't want to change the cb typedef. I can also not make app::callback static as it requires this->db. What is the best way to deal with this problem?

Answer 1

There are two problems:

• std::mem_fn(&app::callback) takes an instance of app as the first parameter.
• The most idiomatic alternative would be to use a capturing lambda such as

  [this] (Json::Value& json) { return callback(json); }
  

  but these cannot be converted to function pointers, which makes implementing generic containers for storing and dynamically dispatching to them extremely difficult to do.

One possible approach is to amend your websocket interface and accept an optional void* context parameter like this:

using cb = int(*)(Json::Value &json, void* ctx);

static void websocket::listen(cb callback, const char* address, void* ctx = nullptr)
{
    ...
}

int app::callback(Json::Value& json)
{
    return db->insert(json);
}

void app::start()
{
    websocket::listen([] (Json::Value &json, void* ctx) -> int {
        return static_cast<app*>(ctx)->callback(json);
    }, path, this);
}

If you prefer more type safety for this erasure, you can consider std::any:

using cb = int(*)(Json::Value &json, std::any ctx);

static void websocket::listen(cb callback, const char* address, std::any ctx = {})
{
    ...
}

int app::callback(Json::Value& json)
{
    return db->insert(json);
}

void app::start()
{
    websocket::listen([] (Json::Value &json, const std::any& ctx) -> int {
        return std::any_cast<app*>(ctx)->callback(json);
    }, path, this);
}

The std::any_cast will throw a std::bad_any_cast if ctx was empty or storing a pointer that wasn't a type erased app*.