C++自身のObserverパターン

Question

私はこのように動作するはずですオブザーバーパターンを設計しています：観察者は

EventDispatcherのAddEventListenerメソッドを呼び出し、eventの名前である文字列を渡し、PointerToItselfとPointerToItsMemberMethodその後、eventはEventDispatcherの内部で発生します。サブスクリプションのリストを調べ、ある場合には、このイベントに割り当てられ、のactionメソッドを呼び出します。

私はこれに来ましたEventDispatcher.h。 注意には擬似コードのビットが含まれています。

ザ・は二つの質問です：私はstruct Subscriptionにactionのタイプを定義するにはどうすればよい

1. ？
2. 正しい方法で動いていますか？

PS：いいえ、私はつもり利用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); 
}; 

このヘッダはu_uは、例えば、関数ポインタとすることができる最も単純な形式で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); 
     }; 
    }; 
}; 

Answer 1

おそらく、あなただけの「ユーザー」によって派生するクラスを作成する必要があります。

class Action { 
    public: 
     friend class EventDispatcher; 

     virtual SomeResultType DoThis() = 0; 

    private: 
     /* Some common data */ 
}; 

ただ、いくつかの派生からクラス・アクションのaddEventListenerに変数型付け渡します。対応するイベントがトリガされたら、共通データを入力してDoThis（）メソッドを呼び出します。

のaddEventListenerについては

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

：

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

アクション派生クラスの例：

class myAction: public Action { 
    public: 
     // Implement the DoThis() method 
     void SomeResultType DoThis() { 
      cout << "Hello World!"; 
      return SomeValue; 
     } 
}; 

// To use the action, 
myAction* act = new myAction; 
myEventDispatcher.AddEventListener(someObserver, "HelloWorld", act); 

これは、アクション（およびコールバック）を実装するための最も安全な方法の一つです。

Answer 2

このような実装します

typedef void (*u_u)(void*); // or whatever arguments u like 

次に、イベントがトリガーされるたびに呼び出される関数を提供するだけです。

void myaction(void* arg) 
{ 
    ... 
} 

Subscription s; 
... 
s.action = myaction; 

Answer 3

アクションクラスを定義するか、ラムダ関数（C++ 11）を渡すことができます。後者の場合、アクションは

function<void (EventDispatcher*)> action; 

として定義することができ、

あなたはおそらく、そのようなあなたのこと、のEventDispatcherにオブザーバーを保存するために、スマート弱いポインタを使用する必要があり

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

を次のようにオブザーバを登録します登録を気にする必要はありません。悪いへ

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); 
    } 
};