C++自己的Observer模式

Question

我設計應該以這種方式工作的觀察者模式：觀察者稱的EventDispatcherAddEventListener方法，並傳遞一個字符串，它是event的名稱，PointerToItself和PointerToItsMemberMethod

之後event發生在EventDispatcher內部;它查看訂閱列表，如果有一些，分配給此事件調用observer的action方法。

我來到這EventDispatcher.h。 小心包含一些僞代碼。

的是兩個問題：

1. 如何定義的action在struct Subscription類型？
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); 
}; 

此頭實現像這樣在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（）方法即可。

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

對於的addEventListener：

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

在其最簡單的形式u_u可以是一個函數指針例如

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

然後你只需提供一個函數，當事件被觸發時被調用。

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

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

Answer 3

您可以定義一個Action類或傳遞一個lambda函數（C++ 11）。在後一種情況下，動作可以被定義爲

function<void (EventDispatcher*)> action; 

，你會如下

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