觀察者模式（Observer）簡介：

定義一個一對多的依賴關系，讓多個觀察者對象監聽某個主題對象，當主題對象的狀態發生改變時，主題對象則通知所有的觀察者對象，做出相應的反應，更新自己的狀態等。

觀察者模式（Observer）結構圖：

C++代碼：

Subject抽象類：

    
    //file: Subject.h
    #pragma once
    #include "Observer.h"
    #include <vector>
    using namespace std;
    
    class Subject
    {
    public:
        Subject();
        virtual ~Subject();
        Observer *m_Observer;
    
        void attach(Observer *pObserver);
        void detach(Observer *pObserver);
    
        void notify();
    
        virtual int getState() = 0;
        virtual void setState(int i) = 0;
    
    private:
        vector<Observer *> m_vtObj;
    };
 

    //file: Subject.cpp
    #include "pch.h"
    #include "Subject.h"
    
    Subject::Subject() {}
    
    Subject::~Subject() {}
    
    void Subject::attach(Observer *pObserver)
    {
        m_vtObj.push_back(pObserver);
    }
    
    void Subject::detach(Observer *pObserver)
    {
        for (vector<Observer *>::iterator iter = m_vtObj.begin(); iter != m_vtObj.end(); iter++)
        {
            if (*iter == pObserver)
            {
                m_vtObj.erase(iter);
                return;
            }
        }
    }
    
    void Subject::notify()
    {
        for (vector<Observer *>::iterator iter = m_vtObj.begin(); iter != m_vtObj.end(); iter++)
        {
            (*iter)->update(this);
        }
    }
 

Observer抽象類：

    //file: Observer.h
    #pragma once
    class Subject;
    
    class Observer
    {
    public:
        Observer();
        virtual ~Observer();
        virtual void update(Subject *ps) = 0;
    };
    

    //file: Observer.cpp
    #include "pch.h"
    #include "Observer.h"
    
    Observer::Observer() {}
    
    Observer::~Observer() {}

 

ConcreteSubject具體主題類：

    //file: ConcreteSubject.h
    #pragma once
    #include "Subject.h"
    
    class ConcreteSubject : public Subject
    {
    public:
        ConcreteSubject();
        virtual ~ConcreteSubject();
        virtual int getState();
        virtual void setState(int i);
    
    private:
        int m_State;
    };
    

    //file: ConcreteSubject.cpp
    #include "pch.h"
    #include "ConcreteSubject.h"
    
    ConcreteSubject::ConcreteSubject() {}
    
    ConcreteSubject::~ConcreteSubject() {}
    
    int ConcreteSubject::getState()
    {
        return m_State;
    }
    
    void ConcreteSubject::setState(int i)
    {
        m_State = i;
    }

ConcreteObserver具體觀察者類：

    //file: ConcreteObserver.h
    #pragma once
    #include "Observer.h"
    #include <string>
    using namespace std;
    
    class ConcreteObserver : public Observer
    {
    public:
        ConcreteObserver(string pName);
        virtual ~ConcreteObserver();
        virtual void update(Subject *ps);
    
    private:
        string m_ObjName;
        int m_ObserverState;
    };

    //file: ConcreteObserver.cpp
    #include "pch.h"
    #include "ConcreteObserver.h"
    #include "Subject.h"
    #include <iostream>
    
    ConcreteObserver::ConcreteObserver(string pName)
    {
        m_ObjName = pName;
    }
    
    ConcreteObserver::~ConcreteObserver() {}
    
    void ConcreteObserver::update(Subject *ps)
    {
        m_ObserverState = ps->getState();
        cout << "update observer " << m_ObjName << " to state "<<m_ObserverState<< " !" << endl;
    }

客戶端代碼：

    //file: ObserverPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
    #include "pch.h"
    #include <iostream>
    #include "ConcreteSubject.h"
    #include "ConcreteObserver.h"
    
    int main()
    {
        Subject *sub = new ConcreteSubject();
        Observer *objA = new ConcreteObserver("A");
        Observer *objB = new ConcreteObserver("B");
    
        sub->attach(objA);
        sub->attach(objB);
    
        sub->setState(101);
        sub->notify();
    
        sub->detach(objB);
    
        sub->setState(102);
        sub->notify();
    
        char c;
        cin >> c;
        delete sub;
        delete objA;
        delete objB;
        return 0;
    }

設計模式——5.觀察者模式