cocos2dx 设计模式 观察者模式 实现

注释：

main()，主程序
IObservable，被观察者接口
CHanFeiZiObservable，被观察者韩非子
IObserver，观察者接口
CLiSiObserver，观察者李斯
CZhouSiObserver观察者周斯
说明：将观察者聚集到被观察者韩非子身边，韩非子的每一个举动都会通知给观察者，如李斯或周斯。
注意：最多允许一个对象既是观察者也是被观察者。就像数据库中的触发器一样，成为一个复杂的链就很难维护了。观察者类似于委托的处理方式。

观察者接口:IObserver

IObserver.h

[cpp] view
plain copy

#ifndef __Observer__IObserver__  

#define __Observer__IObserver__  

  

#include <iostream>  

#include <string>  

using std::string;  

class IObserver  

{     

public:  

    IObserver(string _name){this->m_name = _name;}  

    virtual ~IObserver(void){}  

      

    //一发现别人有动静,自己也要行动起来  

    virtual void Update(string context) = 0;  

      

    //为c++单独增加的函数，用于删除时查找观察者。  

    virtual string GetName() = 0;  

      

protected:  

    string m_name;  

};  

  

  

#endif /* defined(__Observer__IObserver__) */  

观察者李斯:LiSiObserver类

LiSiObserver.h

[cpp] view
plain copy

#ifndef __Observer__LiSiObserver__  

#define __Observer__LiSiObserver__  

  

#include <iostream>  

#include "IObserver.h"  

  

class CLiSiObserver:public IObserver  

{  

public:  

    CLiSiObserver(void);  

    ~CLiSiObserver(void);  

    //一发现别人有动静,自己也要行动起来  

    void Update(string context);  

    string GetName();  

private:  

    void ReportToQinShiHuang(string report);  

};  

  

  

#endif /* defined(__Observer__LiSiObserver__) */  

LiSiObserver.cpp

[cpp] view
plain copy

#include "LiSiObserver.h"  

using std::cout;  

using std::endl;  

using std::string;  

  

CLiSiObserver::CLiSiObserver(void):IObserver("李斯")  

{  

}  

  

CLiSiObserver::~CLiSiObserver(void)  

{  

      

}  

  

//首先李斯是个观察者,一旦韩非子有活动,他就知道,他就要向老板汇报  

void CLiSiObserver::Update(string context)  

{  

    cout << "李斯：观察到韩非子活动，开始向老板汇报了..." << endl;  

    this->ReportToQinShiHuang(context);  

    cout << "李斯：汇报完毕，秦老板赏给他两个萝卜吃吃..." << endl;  

}  

  

//汇报给秦始皇  

void CLiSiObserver::ReportToQinShiHuang(string report)  

{  

    cout << "李斯：报告，秦老板！韩非子有活动了--->" << report.c_str() << endl;  

}  

  

string CLiSiObserver::GetName()  

{  

    return m_name;  

}  

观察者周斯:ZhouSiObserver类

ZhouSiObserver.h

[cpp] view
plain copy

#ifndef __Observer__ZhouSiObserver__  

#define __Observer__ZhouSiObserver__  

  

#include <iostream>  

#include "IObserver.h"  

using std::string;  

class CZhouSiObserver:public IObserver  

{      

public:  

    CZhouSiObserver(void);  

    ~CZhouSiObserver(void);  

    void Update(string context);  

    string GetName();  

private:  

    void Cry(string report);  

};  

  

#endif /* defined(__Observer__ZhouSiObserver__) */  

ZhouSiObserver.cpp

[cpp] view
plain copy

#include "ZhouSiObserver.h"  

using std::cout;  

using std::endl;  

using std::string;  

  

CZhouSiObserver::CZhouSiObserver(void):IObserver("周斯")  

{  

      

}  

  

CZhouSiObserver::~CZhouSiObserver(void)  

{  

      

}  

  

//周斯,看到韩非子有活动,自己就受不了  

void CZhouSiObserver::Update(string context)  

{  

    cout << "周斯：观察到韩非子活动，自己也开始活动了..." << endl;  

    this->Cry(context);  

    cout << "周斯：真真的哭死了..." << endl;  

}  

  

//一看李斯有活动,就哭,痛哭  

void CZhouSiObserver::Cry(string report)  

{  

    cout << "周斯：因为" << report.c_str() << ", ————所以我悲伤呀！" << endl;  

}  

  

string CZhouSiObserver::GetName()  

{  

    return m_name;  

}  

被观察者接口:IObservable

IObservable.h

[cpp] view
plain copy

#ifndef __Observer__IObservable__  

#define __Observer__IObservable__  

  

#include <iostream>  

#include "IObserver.h"  

using std::string;  

  

class IObservable  

{  

public:  

    IObservable(void){}  

    virtual ~IObservable(void){}  

    //增加一个观察者  

    virtual void AddObserver(IObserver *pObserver) = 0;  

      

    //删除一个观察者,——我不想让你看了  

    virtual void DeleteObserver(IObserver *pObserver) = 0;  

      

    //既然要观察,我发生改变了他也应该用所动作——通知观察者  

    virtual void NotifyObservers(string context) = 0;  

  

};  

  

#endif /* defined(__Observer__IObservable__) */  

被观察者韩非子:HanFeiziObservable类

HanFeiziObservable.h

[cpp] view
plain copy

#ifndef __Observer__HanFeiziObservable__  

#define __Observer__HanFeiziObservable__  

  

#include <iostream>  

#include "IObserver.h"  

#include "IObservable.h"  

#include <vector>  

using std::vector;  

  

class CHanFeiziObservable:public IObservable  

{     

public:  

    CHanFeiziObservable(void);  

    ~CHanFeiziObservable(void);  

    void AddObserver(IObserver *pObserver);  

    void DeleteObserver(IObserver *pObserver);  

    void NotifyObservers(string context);  

    //韩非子也是人,也要吃早饭的  

    void HaveBreakfast();  

    //韩非之也是人,是人就要娱乐活动,至于活动时啥,嘿嘿,不说了  

    void HaveFun();  

private:  

    vector<IObserver*> m_observerList;  

    typedef vector<IObserver*>::const_iterator ObserverList_C_iterator;  

};  

  

  

  

#endif /* defined(__Observer__HanFeiziObservable__) */  

HanFeiziObservable.cpp

[cpp] view
plain copy

#include "HanFeiziObservable.h"  

using std::string;  

using std::cout;  

using std::endl;  

  

CHanFeiziObservable::CHanFeiziObservable(void)  

{  

      

}  

  

CHanFeiziObservable::~CHanFeiziObservable(void)  

{  

      

}  

  

void CHanFeiziObservable::AddObserver(IObserver *pObserver)  

{  

    m_observerList.push_back(pObserver);  

}  

  

void CHanFeiziObservable::DeleteObserver(IObserver *pObserver)  

{  

    ObserverList_C_iterator it = m_observerList.begin();  

    for (; it != m_observerList.end(); it++)  

    {  

        string name = (*it)->GetName();  

        if (name.compare(pObserver->GetName())==0)  

        {  

            //找到了删除。  

        }  

    }  

}  

  

void CHanFeiziObservable::NotifyObservers(string context)  

{  

    ObserverList_C_iterator it = m_observerList.begin();  

    for(;it != m_observerList.end();it++)  

    {  

        (*it)->Update(context);  

    }  

}  

  

void CHanFeiziObservable::HaveBreakfast()  

{  

    cout << "韩非子：开始吃饭了..." << endl;  

    this->NotifyObservers("韩非子在吃饭");  

}  

  

  

void CHanFeiziObservable::HaveFun()  

{  

    cout << "韩非子：开始娱乐了..." << endl;  

      

    this->NotifyObservers("韩非子在娱乐");  

}  

主程序:main

main.cpp

[cpp] view
plain copy

#include <iostream>  

#include "IObserver.h"  

#include "LiSiObserver.h"  

#include "ZhouSiObserver.h"  

#include "IObserver.h"  

#include "HanFeiziObservable.h"  

using std::cout;  

using std::endl;  

  

void DoIt()  

{  

      

}  

  

void DoNew()  

{  

    //IHanFeiZi.h, HanFeiZiNew.h, ILiSi.h, LiSi.h  

    // cout << "----------用新的方法试试----------" << endl;  

      

    //CHanFeiZiNew hanfeizi;  

      

    //hanfeizi.HaveBreakfast();  

      

    //hanfeizi.HaveFun();  

}  

  

void DoNewNew()  

{  

    //IObservable.h, HanfeiziObservable.h, IObserver.h, LiSiObserver.h  

    cout << "----------用更新的方法再试试----------" << endl;  

    //两个观察者产生出来  

    IObserver *pLiSi = new CLiSiObserver();  

    IObserver *pZhouSi = new CZhouSiObserver();  

      

    //定义出韩非子  

    CHanFeiziObservable *pHanFeiZi = new CHanFeiziObservable();  

      

    //我们后人根据历史,描述这个场景,有二个人在观察韩非子  

    pHanFeiZi->AddObserver(pLiSi);  

    pHanFeiZi->AddObserver(pZhouSi);  

      

    //然后这里我们看看韩非子在干什么  

    pHanFeiZi->HaveBreakfast();  

      

    delete pLiSi;  

    pLiSi = NULL;  

    delete pHanFeiZi;  

    pHanFeiZi = NULL;  

      

}  

  

  

int main(int argc, const char * argv[])  

{  

      

    //把李斯这个类聚集到韩非子这个类上，这样的话耦合度太高了，还是用更抽象的方式。  

    DoNew();  

      

    //更抽象的方式，想要观察韩非子的人多了去了，不可能只允许李斯观察。  

    DoNewNew();  

  

    // insert code here...  

    std::cout << "Hello, World!\n";  

    return 0;  

}