现在的位置: 首页 > 综合 > 正文

读《大话设计模式》－－－观察者模式(Observer)

2012年11月11日 ⁄ 综合 ⁄ 共 6912字 ⁄ 字号 小 中 大 ⁄ 评论关闭

观察者模式(Observer)又叫发布-订阅(Public/Subscribe)模式.
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个
主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

观察者模式的结构图

 

 

观察者模式一般实现：

  1. // Observer.cpp : Defines the entry point for the console application.
  2. //
  4. #include "stdafx.h"
  5. #include "assert.h"
  6. #include <iostream>
  7. #include <string>
  8. #include <list>
  9. #include <algorithm>
  10. using namespace std;
  11. class Observer
  12. {
  13. private:
  14.  string name;
  15. public:
  16.  virtual bool operator==(const Observer obj) const
  17.  {
  18.   if(obj.name == name)
  19.    return true;
  20.   else
  21.    return false;
  22.  }
  23.  virtual void Update()
  24.  {
  25.   assert(false);
  26.  }
  27. };
  29. void fun(Observer * obj)
  30. {
  31.  obj->Update();
  32. }
  34. class Subject
  35. {
  36. private:
  37.  list<Observer*> observers;
  39.  //增加观察者
  40. public:
  41.  virtual void Attach(Observer *observer)
  42.  {
  43.   observers.push_back(observer);
  44.  }
  45.  //移除观察者
  46.  virtual void Detach(Observer *observer)
  47.  {
  48.   observers.remove(observer);
  49.  }
  50.  //通知
  51.  virtual void Notify()
  52.  {
  53.   for_each(observers.begin(), observers.end(), fun);
  54.  }
  55. };
  57. //具体通知者
  58. class ConcreteSubject : public Subject
  59. {
  60. private:
  61.  string subjectState;
  62.  //具体通知者状态
  63. public:
  65.  string GetSubjectState()
  66.  {
  67.   return subjectState; 
  68.  }
  69.  void SetsubjectState(string value)
  70.  { 
  71.   subjectState = value;
  72.  }
  73. };
  75. class ConcreteObserver : public Observer
  76. {
  77. private:
  78.  string name;
  79.  string observerState;
  80.  ConcreteSubject * subject;
  82. public:
  83.  ConcreteObserver(ConcreteSubject *_subject, const string &_name)
  84.  {
  85.   subject = _subject;
  86.   name = _name;
  87.  }
  88.  virtual bool operator==(const ConcreteObserver obj) const
  89.  {
  90.   if(obj.name == name)
  91.    return true;
  92.   else
  93.    return false;
  94.  }
  95.  //更新
  96.  virtual void Update()
  97.  {
  98.   observerState = subject->GetSubjectState();
  99.   cout << "观察者" << name << "的新状态是" << observerState << endl;
  100.  }
  102.  ConcreteSubject * GetConcreteSubject()
  103.  {
  104.   return subject;
  105.  }
  107.  SetConcreteSubject(ConcreteSubject * value)
  108.  {
  109.   subject = value; 
  110.  }
  111. };
  113. int main()
  114. {
  115.  //观察者模式
  116.  ConcreteSubject * CSub = new ConcreteSubject();
  117.  ConcreteObserver *ConcreteObserver1 = new ConcreteObserver(CSub, "X");
  118.  CSub->Attach(ConcreteObserver1);
  119.  ConcreteObserver *ConcreteObserver2 = new ConcreteObserver(CSub, "Y");
  120.  CSub->Attach(ConcreteObserver2);
  121.  ConcreteObserver *ConcreteObserver3 = new ConcreteObserver(CSub, "Z");
  122.  CSub->Attach(ConcreteObserver3);
  124.  CSub->SetsubjectState("ABC");
  125.  CSub->Notify();
  127.  delete ConcreteObserver1;
  128.  delete ConcreteObserver2;
  129.  delete ConcreteObserver3;
  130.  return 0;
  131. }

观察者模式的具体实现

 

 

 

  1. #include "stdafx.h"
  2. #include "assert.h"
  3. #include <iostream>
  4. #include <string>
  5. #include <list>
  6. #include <algorithm>
  7. using namespace std;
  8. class Observer;
  9. //通知者接口
  10. class Subject
  11. {
  12. private:
  13.  string action;
  14. public:
  15.  virtual void Attach(Observer * observer){};
  16.  virtual void Detach(Observer * observer){};
  17.  void Notify();
  18.  virtual string GetSubjectState(){assert(false);return 0;}
  19.  virtual void SetSubjectState(string &value ){assert(false);}
  20. };
  23. //观察者模式的特点：
  24. //将一个系统分割成一系
  25. //抽象观察者
  26. class Observer
  27. {
  28. protected:
  29.  string name;
  30.  Subject *sub;
  32. public:
  33.  Observer(string _name, Subject *_sub)
  34.  {
  35.   name = _name;
  36.   sub = _sub;
  37.  }
  38.  virtual bool operator==(const Observer obj) const
  39.  {
  40.   if(obj.name == name)
  41.    return true;
  42.   else
  43.    return false;
  44.  } 
  45.  virtual void Update(){cout << "Observer!" << endl; }
  46. };
  48. void fun(Observer *obj)
  49. {
  50.  obj->Update();
  51. }
  53. class Secretary : public Subject
  54. {
  55.  //同事列表
  56. private:
  57.  list<Observer*> observers;
  58.  string action;
  60.  //增加
  61. public:
  62.  virtual void Attach(Observer *observer)
  63.  {
  64.   observers.push_back(observer);
  65.  }
  67.  //减少
  68.  virtual void Detach(Observer *observer)
  69.  {
  70.   observers.remove(observer);
  71.  }
  73.  //通知
  74.  virtual void Notify()
  75.  {
  76.   for_each(observers.begin(), observers.end(), fun);
  77.  }
  79.  //前台状态
  80.  string GetSubjectState()
  81.  {
  82.   return action;
  83.  }
  84.  void SetSubjectState(string value )
  85.  {
  86.   action = value;
  87.  }
  88. };
  90. class Boss : public Subject
  91. {
  92.  //同事列表
  93. private:
  94.  list<Observer*> observers;
  95.  string action;
  96. public:
  98.  //增加
  99.  virtual void Attach(Observer *observer)
  100.  {
  101.   observers.push_back(observer);
  102.  }
  104.  //减少
  105.  virtual void Detach(Observer *observer)
  106.  {
  107.   observers.remove(observer);
  108.  }
  109.  //通知
  110.  virtual void Notify()
  111.  {
  112.   for_each(observers.begin(), observers.end(), fun);
  113.  }
  115.  //老板状态
  116.  virtual string GetSubjectState()
  117.  {
  118.   return action;
  119.  }
  120.  void SetSubjectState(string value)
  121.  {
  122.   action = value;
  123.  }
  124. };
  126. //看股票的同事
  127. class StockObserver : public Observer
  128. {
  129. public:
  130.  StockObserver(string name, Subject *sub)
  131.   : Observer(name, sub)
  132.  {
  133.  }
  135.  virtual void Update()
  136.  {
  137.   cout << sub->GetSubjectState() << name << "关闭股票行情，继续工作！" ;
  138.  }
  139. };
  141. //看NBA的同事
  142. class NBAObserver : public Observer
  143. {
  144. public:
  145.  NBAObserver(string name, Subject *sub)
  146.   : Observer(name, sub)
  147.  {
  148.  }
  150.  virtual void Update()
  151.  {
  152.   cout << sub->GetSubjectState() << name << "关闭NBA直播，继续工作！" ;
  153.  }
  154. };
  157. int main()
  158. {
  159.  //老板胡汉三
  160.  Boss * huhansan = new Boss();
  162.  //看股票的同事
  163.  StockObserver * Yangbailao = new StockObserver("杨白劳", huhansan);
  164.  //看NBA的同事
  165.  NBAObserver * Xier = new NBAObserver("喜儿", huhansan);
  167.  huhansan->Attach(Yangbailao);
  168.  huhansan->Attach(Xier);
  169.  huhansan->Detach(Yangbailao);
  171.  //老板回来
  172.  huhansan->SetSubjectState("我胡汉三回来了！");
  173.  //发出通知
  174.  huhansan->Notify();
  176.  return 0;
  177. }

观察者模式的不足


我们看观察者模式，发现抽象通知者和抽象观察者之间还有很大的耦合性。
这里我们可以通过使用委托来来解决这个问题
委托就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同
的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是
对函数的抽象，是函数的'类',委托的实例将代表一个具体的函数。
一个委托可以搭载多个方法，所有方法被依次唤起。可以使得委托对象所搭载的方法并不
属于同一个类。

 

  1. #include "stdafx.h"
  2. #include "assert.h"
  3. #include <iostream>
  4. #include <string>
  5. #include <list>
  6. #include <algorithm>
  7. using namespace std;
  8. class Observer;
  9. //通知者接口
  10. class Subject
  11. {
  12. private:
  13.  string action;
  14. public:
  15.  virtual void Attach(Observer * observer){};
  16.  virtual void Detach(Observer * observer){};
  17.  void Notify();
  18.  virtual string GetSubjectState(){assert(false);return 0;}
  19.  virtual void SetSubjectState(string &value ){assert(false);}
  20. };
  22. //通知者接口
  23. class Subject
  24. {
  25. public:
  26.  void Notify();
  27.  string GetSubjectState(){};
  28.  void SetSubjectState(){};
  29. };
  31. class StockObserver;
  32. typedef void (*EventHandler)();
  33. //事件处理程序的委托
  34. class Secretary : public Subject
  35. {
  36. //声明一事件Update，类型为委托EventHandler
  37. public:
  38.  void Update(EventHandler eh)
  39.  {
  40.   _eh = eh; 
  41.  }
  42.  void Notify()
  43.  {
  44.   (*_eh)();
  45.  }
  46.  string GetSubjectState()
  47.  {
  48.   return action;
  49.  }
  50.  void SetSubjectState(string value)
  51.  {
  52.   action = value;
  53.  } 
  54. private:
  55.  string action;
  56.  EventHandler _eh;
  57. };
  59. class Boss : public Subject
  60. {
  61.  //声明一事件Update，类型为委托EventHandler
  62. public:
  63.  void Update(EventHandler eh)
  64.  {
  65.   _eh = eh; 
  66.  }
  67.  void Notify()
  68.  {
  69.   (*_eh)();
  70.  }
  71.  string GetSubjectState()
  72.  {
  73.   return action;
  74.  }
  75.  void SetSubjectState(string value)
  76.  {
  77.   action = value;
  78.   cout << action << endl;
  79.  }
  80. private:
  81.  string action;
  82.  EventHandler _eh;
  84. };
  86. //看股票的同事
  87. class StockObserver
  88. {
  89. private:
  90.  string name;
  91.  Subject *sub;
  92. public:
  93.  StockObserver(string _name, Subject *_sub): name(_name), sub(_sub)
  94.  {
  95.  }
  97.  //关闭股票行情
  98.  static void CloseStockMarket()
  99.  {
  100.   cout << "关闭股票行情，继续工作！" ;
  101.  }
  102. };
  104. //看NBA的同事
  105. class NBAObserver
  106. {
  107. private:
  108.  string name;
  109.  Subject *sub;
  110. public:
  111.  NBAObserver(string _name, Subject *_sub): name(_name), sub(_sub)
  112.  {
  113.  }
  115.  //关闭NBA直播
  116.  static void CloseNBADirectSeeding()
  117.  {
  118.   cout << "关闭NBA直播，继续工作！";
  119.  }
  120. };
  122. int main()
  123. {
  124.  //老板胡汉三
  125.  Boss *huhansan = new Boss();
  127.  //看股票的同事
  128.  StockObserver * Yangbailao = new StockObserver("杨白劳", huhansan);
  129.  //看NBA的同事
  130.  NBAObserver * Xier = new NBAObserver("喜儿", huhansan);
  132.  //老板回来
  133.  huhansan->SetSubjectState("我胡汉三回来了！");
  135.  huhansan->Update(Yangbailao->CloseStockMarket);
  136.  //发出通知
  137.  huhansan->Notify();
  138.  huhansan->Update(Xier->CloseNBADirectSeeding); 
  139.  //发出通知
  140.  huhansan->Notify();
  142.  return 0;
  143. }
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞