我正在设计一个应该以这种方式工作的观察者模式:观察者调用 EventDispatcher 的 AddEventListener 方法并传递一个字符串，该字符串是 事件的名称、PointerToItself 和一个 PointerToItsMemberMethod

之后 event 发生在 EventDispatcher 内部；它查看订阅列表，如果有订阅，则分配给此事件调用 observer 的 action 方法。

我来到了这个EventDispatcher.h。 CAUTION 包含一些伪代码。

有两个问题:

1. 如何在 struct Subscription 中定义 action 的类型？
2. 我走的路对吗？

附言:不，我不会使用boost 或任何 其他库。

#pragma once

#include <vector>
#include <string>

using namespace std;

struct Subscription
{
        void*                   observer;
        string                  event;
        /*  u_u  */             action;
};

class EventDispatcher
{
    private:
        vector<Subscription>    subscriptions;

    protected:
        void                    DispatchEvent ( string event );

    public:
        void                    AddEventListener ( Observer* observer , string event , /*  u_u  */ action );
        void                    RemoveEventListener ( Observer* observer , string event , /*  u_u  */ action );
};

此 header 在 EventDispatcher.cpp 中实现如下

#include "EventDispatcher.h"

void    EventDispatcher::DispatchEvent ( string event )
{
    int key = 0;
    while ( key < this->subscriptions.size() )
    {
        Subscription subscription = this->subscriptions[key];
        if ( subscription.event == event )
        {
            subscription.observer->subscription.action;
        };
    };
};

void    EventDispatcher::AddEventListener ( Observer* observer , string event , /* */ action )
{
    Subscription subscription = { observer , event , action );
    this->subscriptions.push_back ( subscription );
};

void    EventDispatcher::RemoveEventListener ( Observer* observer , string event , /* */ action )
{
    int key = 0;
    while ( key < this->subscriptions.size() )
    {
        Subscription subscription = this->subscriptions[key];
        if ( subscription.observer == observer && subscription.event == event && subscription.action == action )
        {
            this->subscriptions.erase ( this->subscriptions.begin() + key );
        };
    };
};

最佳答案

您可以定义一个 Action 类或传递一个 lambda 函数 (C++11)。在后一种情况下， Action 可以定义为

function<void (EventDispatcher*)> action;

然后您将按如下方式注册观察者

Observer * me = this;
observable->AddEventListener (this, "EventName", [me] (EventDispatcher* dispatcher) {
   // code here; me is available
});

您可能应该使用智能弱指针将观察者存储在 EventDispatcher 中，这样您就不必担心注销。

编辑:添加了以下示例(可能只有一个订阅，但应该说明这个想法——你必须小心不要引用不再存在的对象)

struct Observable {
   std::weak_ptr<function<void (const Observable&)>> action;

   void AddEventListener (std::weak_ptr<function<void (const Observable&)>> theAction) {
      action = theAction;
   }

   void EventRaised () {
      if (!action.expired ()) {
         auto theAction = action.lock ();
         (*theAction) (*this);
      }
   }
};

struct Observer {
...
   void CallOnEvent (const Observable & observable) {
      // do something
   }

   // field to store the action as long as it is needed
   std::shared_ptr<function<void (const Observable&)>> action;

   void ... {
      auto me = this;
      action = std::make_shared<function<void (const Observable&)>> (
         [me] (const Observable& observable) {
             me->CallOnEvent (observable);
         }
      );
      // we could have as well used std::bind
      observable.AddEventListener (action);
   }
};

关于C++ 自己的观察者模式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12105274/