Callback to member function using libevent

Question

I am trying to pass a member function to libevent which should be treated as a callback.

#include <event.h>

class A
{
    public:
        void eventcb(evutil_socket_t fd, short events, void *ctx) { }
};


static void global_eventcb(evutil_socket_t fd, short events, void *ctx) { }

typedef void (A::*mthd)(evutil_socket_t, short, void*);

int main(void)
{
    struct event_base *evbase = event_base_new();

    mthd eventcb = &A::eventcb;
    A *instance = new A;
    (instance->*eventcb)(NULL, 0, NULL);

    struct event *timer1 = evtimer_new(evbase, global_eventcb, NULL);
    struct event *timer2 = evtimer_new(evbase, (instance->*eventcb), NULL);

    return 0;
}

I can successfully create a method pointer to eventcb in class A and call it on an instance of A (row 20).

Also, passing a global function (as one would do in C) on row 22 also works fine.

However, on row 23, I attempt to pass my method pointer to libevent, and when I compile this I get the following error (using the clang compiler)

example.cpp:23:25: error: no matching function for call to 'event_new'
        struct event *timer2 = evtimer_new(evbase, (instance->*eventcb), NULL);
                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from example.cpp:1:
In file included from /usr/local/include/event.h:71:
/usr/local/include/event2/event.h:749:40: note: instantiated from:
#define evtimer_new(b, cb, arg)        event_new((b), -1, 0, (cb), (arg))
                                       ^~~~~~~~~
/usr/local/include/event2/event.h:833:15: note: candidate function not viable: no know conversion from '<bound member function type>' to 'event_callback_fn'
      (aka 'void (*)(int, short, void *)') for 4th argument
struct event *event_new(struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
              ^
1 error generated.

What am I doing wrong?

possible duplicate of [Cast member function for create_pthread() call](http://stackoverflow.com/questions/6826620/cast-member-function-for-create-pthread-call) — Mat, Oct 16 '11 at 13:40
It's not an "exact duplicate", but the answers apply just the same. You can't do it directly, a pointer-to-member-function is not compatible with a pointer-to-normal-function. You need some glue code to make it work. — Mat, Oct 16 '11 at 13:41
Allright, I guess I will have to stick with my current solution then: I pass the instance of A to the callback (which is global), and then call the appropriate instance with something like ((A*)ctx)->eventcb(...). Thanks for your reply — Alexander Olsson, Oct 16 '11 at 13:57
@Alexander: no need to guess; that's the only correct solution until support for closures comes along. You could make the callback a static method of the class, but that's about the only potential alteration. — outis, Nov 02 '11 at 00:35
@outis: That is in fact neater from an object oriented point of view. Could you put that comment in an answer so I can accept it. As you said, it's the best solution one can hope to achieve under the circumstances. — Alexander Olsson, Nov 02 '11 at 08:48
@Alexander: it may not be neater, depending on the class's responsibility. Still, posted as an answer to illustrate the concept and implementation. — outis, Nov 03 '11 at 02:22

score 7 · Accepted Answer · answered Nov 03 '11 at 02:17

Instance method pointers need an instance to be invoked on. Since libevent is a C library, it doesn't directly provide a mechanism to associate an instance and an instance method, so you'll have to do it yourself. libevent's various event creation functions let you pass arbitrary data as a callback argument. The instance pointer can be passed via this argument, either directly or packaged in a class with other arguments if the callback takes additional data. The event callback can be a free function or a static method; which approach to take depends on the class's responsibility (in the SOLID, single-responsibilty sense).

An example using a static method and passing no additional data:

class A {
public:
    A(struct event_base *);

    bool start_timer();

    static void invoke_timer_handler(evutil_socket_t fd, short events, void *ctx);
    void handle_timeout(evutil_socket_t fd, short events);

protected:
    struct event_base *evbase;
    struct event *timer;
};

A::A(struct event_base *event_base) : evbase(event_base), timer(NULL) {}

bool A::start_timer() {
    // not thread safe.
    if (! timer) {
        timer = evtimer_new(evbase, &A::invoke_timer_handler, this);
        return true;
    }
    return false;
}

void A::invoke_timer_handler(evutil_socket_t fd, short events, void *ctx) {
    (static_cast<A*>(ctx))->handle_timeout(fd, events);
}

void A::handle_timeout(evutil_socket_t fd, short events) {
    ...
    if (evtimer_del(timer)) {
        // error deleting event
        ...
    } else {
        timer=NULL;
    }
}

In the example, since A::handle_timeout is only called from within A::invoke_timer_handler, it could be made private or protected.

The sample has very basic memory management. In general, the code must ensure the instance (and other callback arguments, if the callback argument isn't simply an A*) exists for the lifetime of the event to prevent access errors. It should also ensure the instance doesn't leak once the event is no longer needed. If the instance owns the event, memory management is relatively straightforward. Concurrency can also add complication that affect memory management.

Existing code-level implementations of anonymous functions (e.g. boost::lambda) and the forthcoming lambda expressions from C++11 rely on the function call operator (operator()), which is unsupported in plain C. Thus anonymous functions are unsuitable for use as libevent callbacks or any other C-library callbacks.

@DinoStray: comments aren't meant for new questions. Search SO to see if your question has been asked; if not, ask it. — outis, Dec 04 '18 at 06:22

score 1 · Answer 2 · edited Aug 04 '23 at 07:03

1

You can use a lambda function, provided it has an empty capture list (i.e. []). You need to pass the A object as a void* and cast it back to the known type inside the callback.

#include <event.h>

class A
{
public:
    void eventcb(evutil_socket_t , short) { }
};

int main()
{
    auto *evbase = event_base_new();

    auto *instance = new A{};
    auto callback =
        [](evutil_socket_t fd, short events, void* instance)
        {
            static_cast<A*>(instance)->eventcb(fd, events);
        };

    struct event *timer2 = evtimer_new(evbase, callback, instance);
}

It's important that the capture list is empty, otherwise the lambda isn't convertible to a function pointer.

edited Aug 04 '23 at 07:03

Toby Speight

27,591
48
66
103

answered Jul 30 '23 at 21:14

Bruno Xavier

23
5

1

Does that actually work? I thought that you'd need a captureless lambda to be able to convert to function pointer that a C library accepts. – Toby Speight Aug 03 '23 at 08:26
Yes it works, no function pointers needed. – Bruno Xavier Aug 03 '23 at 22:13
Sorry, I misread the function. Thanks for the clarification. – Toby Speight Aug 04 '23 at 06:48

Callback to member function using libevent

2 Answers2