设计模式介绍：观察者模式（observer）

   观察者模式（又称发布/订阅模式）定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时,，所有依赖于它的对象都得到通知并被自动更新。

    常见的应用程序框架中有很多观察者模式的应用，比如 MFC 的 Doc/View ，Qt 中的信号与槽、 Model/View Architecture，安卓中的广播接收者（ Broadcast Receiver ）。

    当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变；当一个对象必须通知其它对象，而它又不能假定其它对象是谁，换言之, 你不希望这些对象是紧密耦合的；……这些场景下都可以使用观察者模式。

    下图是观察者模式的 UML 表示：

    下面提供一个观察者模式的实例。这个实例描述的是这么一个情况：有人想看花，希望花开的时候能够得到通知。

    先看目标和观察者接口的声明：

[cpp] view plaincopy

1. class BloomObserver{  
2. public:  
3.     BloomObserver();  
4.     virtual ~BloomObserver();  
5.     virtual void bloomed() = 0;  
6. };  
7. class Rose{  
8. public:  
9.     Rose();  
10.     ~Rose();  
11.     void attach(BloomObserver *pObserver);  
12.     void detach(BloomObserver *pObserver);  
13.     void notify();  
14.     void setBloomed();  
15.     bool bloomed();  
16. private:  
17.     bool m_bBloomed;  
18.     BloomObserverList m_observers;  
19. };  

    再看目标的实现：

[cpp] view plaincopy

1. Rose::Rose():m_bBloomed(false)  
2. {}  
3. void Rose::attach(BloomObserver *pObserver){  
4.     m_observers.add(pObserver);  
5. }  
6. void Rose::detach(BloomObserver *pObserver){  
7.     m_observers.remove(pObserver);  
8. }  
9. void Rose::notify(){  
10.     foreach(BloomObserver *observer, m_observers)  
11.         observer->bloomed();  
12. }  
13. void Rose::setBloomed(){  
14.     m_bBloomed = true;  
15.     notify();  
16. }  
17. bool Rose::bloomed(){  
18.     return m_bBloomed;  
19. }  

    接下来是观察者的实现：

[cpp] view plaincopy

1. class ObserverA : public BloomObserver{  
2.     void bloomed(){  
3.         callFriendsDriveCarToSomewhere();  
4.     }  
5. };  
6.   
7. class ObserverB : public BloomObserver{  
8.     void bloomed(){  
9.         writeBlog();  
10.     }  
11. };  
12.   
13. class ObserverC : public BloomObserver{  
14.     void bloomed(){  
15.         takeCameraToSomewhere();  
16.     }  
17. };  

    最后是驱动代码：

[cpp] view plaincopy

1. int main(int argc, char**argv){  
2.     Rose rose;  
3.     ObserverA *a = new ObserverA;  
4.     ObserverB *b = new ObserverB;  
5.     ObserverC *c = new ObserverC;  
6.     rose.attach(a);  
7.     rose.attach(b);  
8.     rose.attach(c);  
9.   
10.     //doSomethingHere();  
11.     rose.setBloomed();  
12.   
13.     rose.detach(a);  
14.     rose.detach(b);  
15.     rose.detach(c);  
16.   
17.     delete a; delete b; delete c;  
18.     return 0;  
19. }