在没有C ++ 11的情况下用C ++做最简单的回调方法？

Question

What is the cleanest way to do callbacks to a class in C++?

I usually create a function like:

void registerCallback(void(*callback)(void* param), void* param);

And then call it like such:

foo->registerCallback(callbackStatic, this);

Then I add a static function in my class like such:

static void callbackStatic(void* param)
{
    ((Type*)(param))->callback();
}

It works, but it's a pain. I have to create two functions per callback. If I could use C++11, I'd use a lambda instead. Qt has a very nice signal and slot mechanism, but requires a special pre-compiler.

I'm writing a library, so I'd like to keep the requirements as low as possible. No C++11, no boost, etc. Is there a way to build a lambda or signal/slot 'like' callback system only using C++03?

Answer 1

If you are able to start from scratch, I recommend not using functions for callbacks in C++. Instead, use objects.

struct CallbackHandler { virtual void doit() = 0; };

void registerCallback(Callbackhandler* handler);

and then

struct MyCallbackHandler : public CallbackHandler { ... };

registerCallback(new MyCallbackHandler());

Answer 2

Is there a way to build a lambda or signal/slot 'like' callback system only using C++03?

Another way is to use just plain old pure abstract interfaces. This wouldn't require that 2 stage reinforcement of class member functions through the callback function, but just use virtual polymorphism.

You could even use static polymorphism aka as CRTP which also works with the pre c++11 standard.

That all worked from the early standardisations onwards.

---

_{Code samples at @R Sahu's answer}

Answer 3

This might be a bit complicated, but it works for me:

#include <functional>
#include <iostream>
#include <vector>

class C {
public:
    void foo() {
        std::cout << "foo" << std::endl;
    }
};

class D {
public:
    void bar() {
        std::cout << "bar" << std::endl;
    }
};

class abstract_bind {
public:
    virtual void operator()() = 0;
    virtual ~abstract_bind() {}
};

template <typename F, typename T>
class bind : public abstract_bind {
public:
    bind(F f_, T *t_) : f(f_), t(t_) {}

    virtual void operator()() {
        f(t);
    }

private:
    F f;
    T *t;
};


int main() {
    C c1, c2;
    D d;

    std::vector<abstract_bind*> v;

    v.push_back(new bind<std::mem_fun_t<void, C>, C>(std::mem_fun(&C::foo), &c1));
    v.push_back(new bind<std::mem_fun_t<void, C>, C>(std::mem_fun(&C::foo), &c2));
    v.push_back(new bind<std::mem_fun_t<void, D>, D>(std::mem_fun(&D::bar), &d));

    for (size_t i=0; i<v.size(); ++i)
        (*v[i])();

    for (size_t i=0; i<v.size(); ++i)
        delete v[i];

    return 0;
}

The basic idea is that you use std::mem_fun to get the object's member function and bind the corresponding this pointer to it to get "plain" function.

Answer 4

You might keep the C-style callbacks and use a structure for invoking member functions:

// C-style callback
// ================

void(*registered_callback)(void* param) = 0;
void* registered_param = 0;
void registerCallback(void(*callback)(void* param), void* param) {
    registered_callback = callback;
    registered_param = param;
}
void unregisterCallback(void(*callback)(void* param), void* param) {
    registered_callback = 0;
    registered_param = 0;
}

// Invoker
// =======

struct InvokerBase {
    static void callInvoker(void* invoker) {
        reinterpret_cast<InvokerBase*>(invoker)->apply();
    }

    virtual void apply() const = 0;
};

template <typename T>
class Invoker : public InvokerBase
{
    public:
    Invoker(T& object, void(T::*function)())
    : object(&object), function(function)
    {
        registerCallback(callInvoker, this);
    }
    ~Invoker() {
        unregisterCallback(callInvoker, this);
    }

    void apply() const {
        (object->*function)();
    }

    private:
    Invoker(const Invoker&); // no copy
    Invoker& operator = (const Invoker&); // no copy

    T* object;
    void (T::*function)();
};


// Test
// ====

#include<cassert>
#include<iostream>

struct Type {
    void print() { std::cout << "Hello\n"; }
};

int main()
{
    Type x;
    {
        Invoker<Type> print_invoker(x, &Type::print);
        registered_callback(registered_param);
    }
    assert(registered_callback == 0);
}

Answer 5

You could try Synapse, it is a signal-slot library that requires no precompiling. In Synapse any object whatsoever can be used as an emitter: http://zajo.github.io/boost-synapse/