簡單說吧，該模式就只有兩種角色，觀察者物件（主題）和被觀察者物件（觀察者）。主題接收被觀察者，有更新就通知被觀察者。根據依賴倒轉原則高內聚低耦合的目標，我們分別對此增加兩個抽象介面。

概念:
    觀察者模式（Observer），又稱釋出\訂閱模式（Publish\Subscribe）。它定義了一種一對多的依賴關係，讓多個觀察者物件同時監聽某一個主題物件。這個主題物件在狀態發生變化時，會通知所有觀察者物件，使它們能夠自動更新自己。

例子:
    一個鮮活簡單的例子總能讓人輕鬆地理解晦澀的概念。我們來看看一個關於汽車零件更換的例子。
    大家應該有聽說過吧，日本豐田（Toyota）車廠先前由於油門踏板問題，宣佈在美國、歐洲和中國回收逾9百萬輛私家車及貨車，並作零件的更換。這次事件無疑對豐田品牌造成了重大的打擊。
    假設豐田的油門踏板的生產廠商和BMW，Ferrali和Benz一樣，當油門踏板出現問題時，油門踏板廠商會發出一個正式的零件更換通知書，以上所有品牌的汽車都會收到同樣的更新通知：更換油門踏板零件，以保證使用者使用車輛的安全。
    以上可看出，油門踏板廠商發出通知更新，所有的汽車供應商就會收到通知並進行更新，就是觀察者模式。

角色:
    簡單說吧，該模式就只有兩種角色，觀察者物件（主題）和被觀察者物件（觀察者）。主題接收被觀察者，有更新就通知被觀察者。根據依賴倒轉原則高內聚低耦合的目標，我們分別對此增加兩個抽象介面。
1. 抽象主題（Subject）：它把所有對觀察者物件的引用儲存在一個聚集裡，每個主題都可以有任何數量的觀察者。抽象主題提供一個介面，可以增加和刪除觀察者物件；
2. 具體主題（ConcreteSubject）：將有關狀態存入具體觀察者物件；在具體主題的內部狀態改變時，給所有登記過的觀察者發出通知。這裡可指油門踏板廠商；
3. 抽象觀察者（Observer）：為所有的具體觀察者定義一個介面，在得到主題的通知時更新自己；
4. 具體觀察者（ConcreteObserver）：實現抽象觀察者角色所要求的更新介面，以便使本身的狀態與主題的狀態相協調。這裡可指BMW，Ferrali和Benz。

UML圖:

程式碼:

#pragma warning(disable:4786)

#include<iostream>
#include <vector>
#include <list>
#include <string>

using namespace std;

//具體觀察者結構體
typedef struct ObserverItems
{
    string strName;
    Observer* pObserver;
}ObserverSets;

//抽象觀察者
class Observer
{
public:
    virtual
 
 void Update()=0;
};

//抽象通知者
class Notice
{
public:
    virtual void AddObserver(ObserverSets* ob)=0;
    virtual void RemoveObserver(ObserverSets* ob)=0;
    virtual void Notify()=0;
};

//具體通知者
class ConcreteNotice:public Notice
{
public:
    virtual ~ConcreteNotice()
    {
        list<ObserverSets*>::iterator stIter;

        for (stIter=observers.begin(); stIter!=observers.end(); stIter++)
        {
            if ((*stIter)->pObserver!=NULL)
            {
                delete (*stIter)->pObserver;
                (*stIter)->pObserver=NULL;
            }

            if ((*stIter)!=NULL)
            {
                delete (*stIter);
                (*stIter)=NULL;
            }
        }
    }

public:
    string getState()
    {
        return m_noticeState;
    }

    void setState(string strState)
    {
        m_noticeState = strState;
    }

public:
    //增加觀察者
    void AddObserver(ObserverSets* ob)
    {
        observers.push_back(ob);
    }

    //去除觀察者
    void RemoveObserver(ObserverSets* ob)
    {
        list<ObserverSets*>::iterator stIter;

        for (stIter=observers.begin(); stIter!=observers.end(); )
        {
            if ((*stIter)->strName==ob->strName)
            {
                observers.erase(stIter);

                break;
            }
            else
            {
                ++stIter;
            }
        }
    }

    //通知更新
    void Notify()
    {
        list<ObserverSets*>::iterator stIter;

        for (stIter=observers.begin(); stIter!=observers.end(); stIter++)
        {
            (*stIter)->pObserver->Update();
        }
    }

private:
    string m_noticeState;
    list<ObserverSets*> observers;
};

//具體觀察者
class ConcreteObserver:public Observer
{
public:
    ConcreteObserver(ConcreteNotice* notice, string name)
    {
        this->m_Notice = notice;
        this->m_strName = name;
    }

    void Update()
    {
        m_strObserverState = m_Notice->getState();
        cout<<"通知："<<m_strName<<" 要更換："<<m_strObserverState<<endl;
    }

private:
    string m_strName;
    string m_strObserverState;
    ConcreteNotice* m_Notice;
};


void main()
{
    ConcreteNotice* notice = new ConcreteNotice;
    ObserverSets* pObItem = new ObserverSets;
    Observer* pOb=NULL; 

    //新增BMW車觀察者
    pOb = new ConcreteObserver(notice, "BMW車");
    pObItem->pObserver = pOb;
    pObItem->strName = "BMW車";
    notice->AddObserver(pObItem);

    //新增Ferrali車觀察者
    pObItem = new ObserverSets;
    pOb = new ConcreteObserver(notice, "Ferrali車");
    pObItem->pObserver = pOb;
    pObItem->strName = "Ferrali車";
    notice->AddObserver(pObItem);

    //新增Benz車觀察者
    pObItem = new ObserverSets;
    pOb = new ConcreteObserver(notice, "Benz車");
    pObItem->pObserver = pOb;
    pObItem->strName = "Benz車";
    notice->AddObserver(pObItem);

    //去除Benz車觀察者
    notice->RemoveObserver(pObItem);

    notice->setState("輪胎");
    notice->Notify();

    delete notice;
    notice = NULL;

    return;
}

發散:
    我們知道實現C++的多型有三種方法：函式過載，模板函式和虛擬函式。虛擬函式實現的多型稱為動態多型，上面程式碼有以下特點：
1. 子類的物件轉換給父類的物件，我們稱為向上轉型。它是安全的，自動完成，並且會丟失子型別的資訊；
2. 為了解決子型別資訊丟失的問題（子類物件轉換給父類），父類必須實現了一個虛擬函式；
3. 子類有完全相同的函式，覆蓋重寫父類的虛擬函式，這樣便能實現動態多型了（否則只能用指標或引用了）。

應用場景:
1. 當一個物件改變的時候同時需要改變其他物件，而且也可以不知道具體有多少物件有待改變；
2. 物件僅需要將自己的更新通知給其他物件而不需要知道其他物件的細節。

優點:
1. Subject在傳送廣播通知的時候，無須指定具體的Observer，Observer可以自己決定是否要訂閱Subject的通知；
2. 高內聚、低耦合，可各自獨立改變。

缺陷:
1. 鬆偶合導致程式碼關係不明顯，有時可能難以理解;
2. 如果一個Subject被大量Observer訂閱的話，在廣播通知的時候可能會有效率問題。