Is this the correct way to implement custom event handlers?

Question

I was looking for a way of adding custom event handlers as a c++ class member function. Found that this code actually works. I need to separate library class and user code, allowing user code to customize library class. Here is concept of code. Is it correct to do so? Thread safeness is out of scope in my question. Compiler is gcc. User code is very very neat. no inheritance, virtual functions, templates used

#include <stdio.h>

typedef void fn();

class aaa
{
  public:
  aaa() : customhandler(NULL) {}
  fn *customhandler;
};

// user code start

void dostuff() {
  printf("doing stuff 1\n");
}
void dostuff2() {
  printf("doing stuff 2\n");
}
int main()
{
  aaa aaa1;
  aaa1.customhandler = &dostuff;
  aaa1.customhandler();
  aaa1.customhandler = &dostuff2;
  aaa1.customhandler();
}

If it compiles and works for you, than it's fine. Otherwise what is your question? — C.J., Aug 12 '11 at 19:43
`User code is very very neat` & `[has] no inheritance, virtual functions, templates used` Those two statements are mutually exclusive. — Alok Save, Aug 12 '11 at 19:43

score 2 · Answer 1 · answered Aug 12 '11 at 19:47

Well, if you had a Boost libraries or C++0x-enabled compiler, you could have had a code like this:

#include <cstdio>
#include <functional>

struct Foo
{
    std::function<void ()> handler;

    void invoke ()
    {
        if (handler)
        {
            handler ();
        }
        else
        {
            printf ("Oops, handler is not there!\n");
        }
    }
};

static void myHandler1 (int arg)
{
    printf ("Handler #1 (arg=%d)\n", arg);
}

static void myHandler2 ()
{
    printf ("Handler #2\n");
}

int main ()
{
    Foo f;

    f.invoke ();

    f.handler = std::bind (&myHandler1, 13);
    f.invoke ();

    f.handler = &myHandler2;
    f.invoke ();
}

The nice thing about it is that you can have functions or functors bound to a handler with optional additional arguments.

Your original code will also work, but what if I want to invoke a class's method and not a plain function? What if I want to also pass some state that I can access inside the handler when it is invoked? That's one of the many reasons why std::function made it into the C++ standard.

the custom functions are static. is there a way to make them non-static? — tohaz, Aug 12 '11 at 20:04
@tohaz: static in my example can be removed if function is not local to a translation unit. So yes, static can be removed without breaking intended functionality. — , Aug 12 '11 at 20:11

score 1 · Accepted Answer · answered Aug 12 '11 at 19:51

I tried your code and it works fine. Just for your information, there is another way to code your function pointer. In which case your code can be simplified just a little. Here I use a slightly different syntax for the typdef for the function pointer, which lets you drop the & symbols.

#include "stdafx.h"
#include <stdio.h>

typedef void (*fn)();

class aaa
{
public:
    aaa() : customhandler(NULL) {}
    fn customhandler;
};

void dostuff() {
    printf("doing stuff 1\n");
}
void dostuff2() {
    printf("doing stuff 2\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    aaa aaa1;
    aaa1.customhandler = dostuff;
    aaa1.customhandler();
    aaa1.customhandler = dostuff2;
    aaa1.customhandler();
    return 0;
}

Both ways are just fine, I just thought I'd show you another way to do this.

Is this the correct way to implement custom event handlers?

2 Answers2