观察者模式与Boost.Signals

 

1）  观察者模式定义

略，各种设计模式的书上都有定义。

2）  观察者模式一般实现

观察者模式一般实现，都是“被观察者”保存一个“观察者”的列表，循环这个列表来通知“观察者”。代码，其中使用了boost的智能指针shared_ptr：

1. #include <iostream>
2. #include <list>
3. #include "boost/shared_ptr.hpp"
4. using namespace std;
5. using namespace boost;
6. //观察者基类
7. class Observer
8. {
9. public:
10. //处理被观察者的通知
11. virtual void update(const int i) = 0;
12. };
13. //观察者类A
14. class ObserverA : public Observer
15. {
16. public:
17. virtual void update(const int i)
18. {
19. cout << "ObserverA.update(" << i << ")" << endl;
20. }
21. };
22. //观察者类B
23. class ObserverB : public Observer
24. {
25. public:
26. virtual void update(const int i)
27. {
28. cout << "ObserverB.update(" << i << ")" << endl;
29. }
30. };
31. //被观察者基类
32. class Subject
33. {
34. public:
35. virtual ~Subject()
36. {
37. }
38. //注册观察者
39. virtual void reg(const shared_ptr<Observer>& pObs) = 0;
40. //取消注册观察者
41. virtual void unreg(const shared_ptr<Observer>& pObs) = 0;
42. //通知观察者
43. virtual void notify(const int i) = 0;
44. };
45. //被观察者类A
46. class SubjectA : public Subject
47. {
48. public:
49. virtual void reg(const shared_ptr<Observer>& pObs)
50. {
51. m_lstObs.push_back(pObs);
52. }
53. virtual void unreg(const shared_ptr<Observer>& pObs)
54. {
55. for (list<shared_ptr<Observer> >::iterator it = m_lstObs.begin();
56. it != m_lstObs.end();)
57. {
58. if (pObs == *it) m_lstObs.erase(it++);
59. else ++it;
60. }
61. }
62. virtual void notify(const int i)
63. {
64. for (list<shared_ptr<Observer> >::iterator it = m_lstObs.begin();
65. it != m_lstObs.end(); ++it)
66. {
67. (*it)->update(i);
68. }
69. }
70. protected:
71. //观察者类别
72. list<shared_ptr<Observer> > m_lstObs;
73. };
74. int main()
75. {
76. //被观察者pSubA
77. shared_ptr<Subject> pSubA(new SubjectA);
78. //观察者pObsA
79. shared_ptr<Observer> pObsA(new ObserverA);
80. //观察者pObsB
81. shared_ptr<Observer> pObsB(new ObserverB);
82. //注册pObsA
83. pSubA->reg(pObsA);
84. //注册pObsB
85. pSubA->reg(pObsB);
86. //通知
87. pSubA->notify(1);                //显示
88. //ObserverA.update(1)
89. //ObserverB.update(1)
90. //取消pObsA的注册
91. pSubA->unreg(pObsA);
92. //通知
93. pSubA->notify(2);                //显示
94. //ObserverB.update(2)
95. return 0;
96. }

3）  观察者模式Boost.Signals实现

Boost.Signals是基于函数指针或函数对象来实现观察者模式的。其中Boost.Signals2是线程安全版本。代码：

1. #include <iostream>
2. #include <list>
3. #include "boost/shared_ptr.hpp"
4. #include "boost/signal.hpp"
5. using namespace std;
6. using namespace boost;
7. //使用函数对象来实现
8. //观察者类A
9. class ObserverA
10. {
11. public:
12. void operator()(const int i)
13. {
14. cout << "ObserverA(" << i << ")" << endl;
15. }
16. };
17. //观察者类B
18. class ObserverB
19. {
20. public:
21. void operator()(const int i)
22. {
23. cout << "ObserverB(" << i << ")" << endl;
24. }
25. };
26. int main()
27. {
28. //被观察者sig
29. signal<void (const int)> sig;
30. //注册观察者ObserverA
31. signals::connection connA = sig.connect(ObserverA());
32. //注册观察者ObserverB
33. sig.connect(ObserverB());
34. //通知
35. sig(1);                 //显示
36. //ObserverA(1)
37. //ObserverB(1)
38. //取消obsA的注册
39. connA.disconnect();
40. //通知
41. sig(2);                 //显示
42. //ObserverB(2)
43. return 0;
44. }

Boost.Signals还支持被观察者分组，可以对整个组进行“通知”、取消注册。另外，Boost.Signals需要编译才能使用。