码迷，mamicode.com
首页 > 编程语言 > 详细

C++设计模式实现--观察者

时间：2014-06-19 09:37:57      阅读：317      评论：0      收藏：0      [点我收藏+]

标签：style   class   blog   http   tar   ext   

概述

　　在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” ——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

　    意图

　　定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。[GOF 《设计模式》]

        特点：
        1、  Subject和Observer之间是松偶合的，分别可以各自独立改变。
        2、  Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
        3、  遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
        应用场景：
        1、  对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。
        2、  对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

        UML图

       bubuko.com,布布扣

          代码实现

[cpp] view plaincopy
  1. #pragma once  
  2. #include <string>  
  3. #include <list>  
  4. #include "Define.h"  
  5.   
  6. class IObserver;  
  7. class ISubject  
  8. {  
  9. public:  
  10.     ISubject(void);  
  11.     virtual ~ISubject(void);  
  12.   
  13.     virtual int Attach(IObserver* pObs) = 0;  
  14.   
  15.     virtual int Detach(IObserver* pObs) = 0;  
  16.   
  17.     virtual int Notify() = 0;  
  18.   
  19.     virtual State GetState() = 0;  
  20.   
  21.     virtual void SetState(const State& state) = 0;  
  22.   
  23. protected:  
  24.     typedef std::list<IObserver*> L_OBS;  
  25.     L_OBS   m_obsArray;  
  26. };  
[cpp] view plaincopy
  1. #pragma once  
  2. #include "ISubject.h"  
  3.   
  4. class CSubjectA : public ISubject  
  5. {  
  6. public:  
  7.     CSubjectA(void);  
  8.     virtual ~CSubjectA(void);  
  9.   
  10.     virtual int Attach(IObserver* pObs);  
  11.   
  12.     virtual int Detach(IObserver* pObs);  
  13.   
  14.     virtual int Notify();  
  15.   
  16.     virtual State GetState();  
  17.   
  18.     virtual void SetState(const State& state);  
  19.   
  20. private:  
  21.   
  22.     State m_state;  
  23. };  
[cpp] view plaincopy
  1. #include "CSubjectA.h"  
  2. #include "IObserver.h"  
  3.   
  4. CSubjectA::CSubjectA(void)  
  5. {  
  6. }  
  7.   
  8. CSubjectA::~CSubjectA(void)  
  9. {  
  10.     if (!m_obsArray.empty())  
  11.     {  
  12.         m_obsArray.clear();  
  13.         L_OBS().swap(m_obsArray);  
  14.     }  
  15. }  
  16.   
  17. int CSubjectA::Attach( IObserver* pObs )  
  18. {  
  19.     m_obsArray.push_back(pObs);  
  20.   
  21.     return 0;  
  22. }  
  23.   
  24. int CSubjectA::Detach( IObserver* pObs )  
  25. {  
  26.     m_obsArray.remove(pObs);  
  27.   
  28.     return 0;  
  29. }  
  30.   
  31. int CSubjectA::Notify()  
  32. {  
  33.     L_OBS::iterator it_beg, it_end=m_obsArray.end();  
  34.     for (it_beg=m_obsArray.begin(); it_beg!=it_end; ++it_beg)  
  35.     {  
  36.         (*it_beg)->Update();  
  37.     }  
  38.   
  39.     return 0;  
  40. }  
  41.   
  42. State CSubjectA::GetState()  
  43. {  
  44.     return m_state;  
  45. }  
  46.   
  47. void CSubjectA::SetState( const State& state )  
  48. {  
  49.     m_state = state;  
  50. }  
[cpp] view plaincopy
  1. #pragma once  
  2. #include "Define.h"  
  3.   
  4. class IObserver  
  5. {  
  6. public:  
  7.     IObserver(void);  
  8.     virtual ~IObserver(void);  
  9.   
  10.     virtual int Update() = 0;  
  11. };  
[cpp] view plaincopy
  1. #pragma once  
  2. #include "IObserver.h"  
  3.   
  4. class ISubject;  
  5. class CObserveA : public IObserver  
  6. {  
  7. public:  
  8.     CObserveA(ISubject* pSubject);  
  9.     virtual ~CObserveA(void);  
  10.   
  11.     virtual int Update();  
  12.   
  13. private:  
  14.     ISubject* m_pSubject;  
  15. };  
[cpp] view plaincopy
  1. #include "CObserveA.h"  
  2. #include <cstdio>  
  3. #include "ISubject.h"  
  4.   
  5. CObserveA::CObserveA(ISubject* pSubject)  
  6.     :m_pSubject(pSubject)  
  7. {  
  8.     m_pSubject->Attach(this);  
  9. }  
  10.   
  11. CObserveA::~CObserveA(void)  
  12. {  
  13.     m_pSubject->Detach(this);  
  14. }  
  15.   
  16. int CObserveA::Update()  
  17. {  
  18.     State str = m_pSubject->GetState();  
  19.   
  20.     printf("first get: [%s]\n", str.c_str());  
  21.     return 0;  
  22. }  
[cpp] view plaincopy
  1. #include "CSubjectA.h"  
  2. #include "CObserveA.h"  
  3.   
  4. int main()  
  5. {  
  6.     CSubjectA subA;  
  7.     CObserveA first(&subA);  
  8.   
  9.     subA.SetState("test set state");  
  10.   
  11.     subA.Notify();  
  12.   
  13.     return 0;  
  14. }  

C++设计模式实现--观察者,布布扣,bubuko.com

C++设计模式实现--观察者

标签：style   class   blog   http   tar   ext   

原文地址：http://blog.csdn.net/l_andy/article/details/30055427
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！