C++：作为事件回调的类成员函数

Question

我正在尝试向我的项目添加一个简单的消息传递系统，其中事件可以由函数调用，这将导致注册到该事件的所有回调被调用。

现在，执行此操作的逻辑方法是使用函数指针。可以轻松地将指向所需回调函数的指针传递给事件管理器以进行注册。事件回调函数始终返回 int 并采用 void* 作为参数。

但是，我不想将静态全局函数注册为我的事件回调 - 我想使用类成员函数来实现。

• 是否可以使用 C++ 来完成此任务？存储和调用指向不同类但具有相同函数头的成员函数的指针。

• 如果这是不可能的，您对我如何解决这个问题有什么建议吗？我真的很想将事件监听器直接添加到我的类中。

Answer 1

是的，这是可能的。 C++0x 有处理此问题的 function 类< /a>，正如其他人指出的那样，Boost 具有类似的功能。

您也可以自己编写，但语法不适合胆小的人：

#include <iostream>

class Callable
{
    public:

        virtual ~Callable() {}
        virtual int operator() (void* args) = 0;
};

class CallableFreeFunction  : public Callable
{
    public:

        CallableFreeFunction(int (*func)(void*)) : func_(func) {}

        virtual int operator() (void* args) { return (*func_)(args); }

    private:

        int (*func_)(void*);
};

template <typename tClass>
class ClassMemberCallable : public Callable
{
    public:

        ClassMemberCallable(tClass* instance, int (tClass::*memberfunction)(void*)) : instance_(instance), memberfunc_(memberfunction) {}

        virtual int operator() (void* args) { return (instance_->*memberfunc_)(args); }

    private:

        tClass* instance_;
        int (tClass::*memberfunc_)(void*);
};

class Foo
{
    public:

        int derp(void* args)
        {
            std::cout << args << '\n';
            return 2;
        }
};

int freefunctionfoo(void* args)
{
    std::cout << "free" << args << '\n';
    return 2;
}

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

    Callable* callable = new ClassMemberCallable<Foo>(&myfoo, &Foo::derp);

    (*callable)(0);

    delete callable;

    callable = new CallableFreeFunction(freefunctionfoo);

    (*callable)(0);

    delete callable;

    std::cin.get();

    return 0;
}

这演示了一种以不透明的方式处理自由函数和成员函数的方法。这是一个简单的示例，可以通过多种方式使其更加通用和健壮。我建议您访问以下页面以获取语法帮助：

http://www.newty.de/fpt /index.html

http://www.parashift .com/c++-faq-lite/pointers-to-members.html

我还建议查看此内容以获取更多想法：

http://www.codeproject.com/KB/cpp/FastDelegate.aspx

Answer 2

当然有可能！看看 Boost.Signal2 和 Boost.Bind。

Boost.Signal2 基本上实现了一个信号和槽系统，这正是您所需要的。
然后，您可以使用 boost::bind（它是 std::bind1st 和 std::bind2nd 的泛化）来获取函数对象包装器基本上任何你能想到的东西（在你的例子中，成员方法）。真的很强大。

请参阅此官方Boost 教程。

Answer 3

这是我做这样的工作的不太好的尝试：
首先，您需要一个基本事件处理程序类，现在我们将其称为 EvtHandler：

class Event; //implement this yourself, it shall contain general but good info about event

class EvtHandler
{
public:
    virtual void handleEvent (Event & evt);
};

然后，每个应该以某种方式处理事件的类都应该从此类派生，并且它们可以实现新的只要它们返回相同的数据类型（在本例中为void）并接收相同的参数（在本例中为Event），就可以尽可能多地执行函数。像这样：

class Foo : public EvtHandler
{
public:
    void handleFooEvent (Event & event);
};

然后我为每个特殊事件实现了消息中心，它必须注册侦听器并在需要时分派事件：

class ShutdownMessageCenter
{
typedef std::map<EventHandler *, event_func> ListenerMap; 
public:

    void register (EvtHandler * handler, void(EvtHandler::*memFunc)(Event &)) {
        m_lmap[handler] = memFunc;
    }

     void callListeners () {
         Event shutdown_event (EM_SHUTDOWN /*just imagine this can mean something, idk*/);
         ListenerMap::iterator itr = m_lmap.begin ();
         for (; itr != m_lmap.end(); ++itr) {
            EvtHandler * handler = itr->first;
            void (EvtHandler::*func)(Event &) = itr->second;
            (handler->*func)(shutdown_event);
          }
      }

private:
   ListenerMap m_lmap;
};

然后您可以将 EvtHandler 注册到这个特定的消息中心！

ShutdownMessageCenter message_center;
EvtHandler * some_handler = new EvtHandler ();
Foo * some_foo = new Foo ();
message_center.register (some_handler, &EvtHandler::handleEvent);
message_center.register (some_foo, static_cast<void (EvtHandler::*)(Event &)>(&Foo::handleFooEvent);
message_center.callListeners ();

但这一点也不好，只是想分享一下！抱歉打扰了，哈哈！

Answer 4

我不完全确定你想要存档什么，但也许你应该看看 Boost Signals2

如果您想创建某种信号/槽机制，它会非常有帮助。

Answer 5

不，这是不可能的（除非您使用 .net 执行 c++/cli）。

现在，您仍然可以创建静态函数，将一个对象作为参数传递给它们，它们唯一要做的就是调用该对象上的成员函数。 （实际上首先需要演员阵容）。

Answer 6

我最接近的做法是将静态成员函数注册为回调。除了事件处理程序发送的参数之外，静态成员还接受对象（this）指针作为参数，并使用 this 来调用成员函数。

class myClass{
public:
  static void callback(void *arg, void *obj)
  {
    if (obj)
      reinterpret_cast<myClass*>(obj)->cb(arg);
  }

private:
  void cb(void *arg);
};

向您的处理程序注册 myClass::callback 和 this。如果您的返回内容受到限制，您可能需要将其包装在 arg 引用的结构中。

Answer 7

我正在将 lukes 答案与 SWIG 一起使用，因为 SWIG 不支持所有 C++11 功能...这可能可以通过 Parsa Jamshidis 方法进一步改进。

我修改了它以涵盖更多情况（可变数量的参数和可变返回类型）：

#include <iostream>

template <typename R, typename ...T>
class Callback
{
public:
    virtual ~Callback() {}
    virtual R operator() (T... args) = 0;
};

template <typename R, typename ...T>
class FreeCallback : public Callback<R, T...>
{
public:
    FreeCallback(R(*func)(T...)) : func_(func) {}
    virtual R operator() (T... args) { return (*func_)(args...); }
private:
    R(*func_)(T...);
};

template <typename tClass, typename R, typename ...T>
class MemberCallback : public Callback<R, T...>
{
public:
    MemberCallback(tClass* instance, R (tClass::*memberfunction)(T...)) : instance_(instance), memberfunc_(memberfunction) {}
    virtual R operator() (T... args) { return (instance_->*memberfunc_)(args...); }
private:
    tClass * instance_;
    R (tClass::*memberfunc_)(T...);
};

class foo {
  public:
  Callback<int, int> *IntCallback;
  Callback<int, int, double, double> *IntDoubleDoubleCallback;
};

class blub {
  public:
  int func1(int i) {
    std::cout << "args: " << i << std::endl;
    return 1;
  }
  int func2(int i, double d1, double d2){
    std::cout << "args: " << i << " " << d1 << " " << d2 << std::endl;
    return 0;
  }
};

  int freeFunc1(int i) {
    std::cout << "args: " << i << std::endl;
    return 1;
  }
  int freeFunc2(int i, double d1, double d2){
    std::cout << "args: " << i << " " << d1 << " " << d2 << std::endl;
    return 0;
  }

int main() {
  foo f;
  blub b;
  f.IntCallback = new MemberCallback<blub, int, int>(&b, &blub::func1);
  f.IntDoubleDoubleCallback = new MemberCallback<blub, int, int, double, double>(&b, &blub::func2);

  Callback<int, int> *IntFreeCallback = new FreeCallback<int, int>(&freeFunc1);
  Callback<int, int, double, double> *IntDoubleDoubleFreeCallback = new FreeCallback<int, int, double, double>(&freeFunc2);

  int ret = (*IntFreeCallback)(42);
  std::cout << "ret freeFunc1: " << ret << std::endl;
  ret = (*IntDoubleDoubleFreeCallback)(42, 3.1415, 2.7182);
  std::cout << "ret freeFunc2: " << ret << std::endl;


  ret = (*f.IntCallback)(42);
  std::cout << "ret func1: " << ret << std::endl;
  ret = (*f.IntDoubleDoubleCallback)(42, 3.1415, 2.7182);
  std::cout << "ret func2: " << ret << std::endl;
  std::cout << "Hello World!\n";
  // cleanup not done here...
}