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

观察者模式(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. }