c++ - 事件回调守护进程

Question

我正在用 C++ 开发一个事件守护进程，我想使用成员函数回调。基本上，事件队列会收集守护进程持续服务的事件。有一个带有 ID 的基类 Event 结构，所有事件都将从它派生。我希望为每个事件注册的方法在其签名中使用派生的事件类型。

struct Event
{
    unsigned int eventId;
};

struct EventA : public Event
{
    unsigned int x;
    unsigned int y;
};

// and struct EventB, EventC (use your imagination...)

const unsigned int EVENT_A = 1;
const unsigned int EVENT_B = 2;
const unsigned int EVENT_C = 3;

class Foo
{
public:
    void handlerMethod_A(const EventA& e);
    void handlerMethod_B(const EventB& e);
};

class Bar
{
public:
    void handlerMethod_C(const EventC& e);
};

然后守护进程将允许这些类使用它们的“this”指针订阅它们的成员函数。

class EventDaemon
{
public:

    void serviceEvents();

    template <class CallbackClass, class EventType>
    void subscribe(
        const unsigned int eventId,
        CallbackClass* classInstancePtr,
        void (CallbackClass::*funcPtr)(EventType));

private:
    Queue<Event*> eventQueue_;
};

所以在这个类之外你可以做这样的事情:

EventDaemon* ed = new EventDaemon();
Foo* foo = new Foo();
Bar* bar = new Bar();

ed->subscribe(EVENT_A, foo, Foo::handlerMethod_A);
ed->subscribe(EVENT_B, foo, Foo::handlerMethod_B);
ed->subscribe(EVENT_C, bar, Bar::handlerMethod_C);

EventDaemon 循环将按照

void EventDaemon::serviceEvents()
{
    while (true)
    {
        if (eventQueue_.empty())
        {
            // yield to other threads
        }
        else
        {
            // pop an event out of the FIFO queue
            Event e* = eventQueue_.pop();
            // somehow look up the callback info and use it
            classInstancePtr->*funcPtr(reinterpret_cast<?*>(e));
        }
    }
}

所以我的问题是如何按事件 ID 将“this”指针和成员函数指针存储在某种数组中。这样我就可以通过使用 e->eventId 和事件类型以及重新解释转换来查找“classInstancePtr”和“funcPtr”。

Answer 1

你太辛苦了。使用提升功能:

http://www.boost.org/doc/libs/1_47_0/doc/html/function.html

无论您是否有对象，这些都有效。它们会增加您的编译时间。

请注意，每当您遇到这些类型的问题时，您知道很多人一定有同样的问题，可能有一个简单的选项，如果它不在标准库中，它可能在 boost 中。

作为对 Nick 的回应，我经常将 boost 函数对象放入 vector 中等等。

我发现，虽然 boost 函数对象可以保存对象引用，但让它们这样做会导致对象生命周期出现错误，最好让它们保存类对象的拷贝(但是你会遇到同样的错误您尝试持有对您不一定控制其生命周期的对象实例的引用)。模式:

class Foo
{
  struct Member
  {
     // member variable definitions
  };
  shared_ptr<Member> m_; // the only real member variable
public:
  // etc. including the all-important copy
  // constructor and assignment operator and
  // don't forget the member function that gets stuck into
  // the boost function as a callback!
};

所有成员变量都保存在 shared_ptr 中可以实现良好的性能，并且您不必担心函数对象保存的对象的生命周期，因为您可以按值复制它们。线程代码(我现在似乎总是在写)需要额外的东西，比如 Member 中的至少一个 boost mutex 元素或一些其他方式来确保值不会被踩踏。