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

最新推荐文章于 2023-12-12 22:09:20 发布

zhanghow

最新推荐文章于 2023-12-12 22:09:20 发布

阅读量1.1k

点赞数

分类专栏： cocos2d-x 3.0

本文链接：https://blog.csdn.net/zhanghow/article/details/53439485

版权

cocos2d-x 3.0 专栏收录该内容

33 篇文章 1 订阅

订阅专栏

注释：

main()，主程序

IObservable，被观察者接口

CHanFeiZiObservable，被观察者韩非子

IObserver，观察者接口

CLiSiObserver，观察者李斯

CZhouSiObserver观察者周斯

说明：将观察者聚集到被观察者韩非子身边，韩非子的每一个举动都会通知给观察者，如李斯或周斯。

注意：最多允许一个对象既是观察者也是被观察者。就像数据库中的触发器一样，成为一个复杂的链就很难维护了。观察者类似于委托的处理方式。

观察者接口:IObserver

IObserver.h

[cpp]view plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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 plaincopy 
   
 #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;  
 }  