观察者模式

观察者模式的UML图如下：

 

这里使用了依赖倒置原则，依赖于抽象，不能依赖于具体实现。底层不能依赖高层。高层是抽象接口，且是相对稳定的。

 

// ConsoleApplication43.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

class Observer
{
public:
    virtual void update(int) = 0;
};

class Subject
{
public:
    void attach(Observer*);
    void detach(Observer*);
    void notify();
    virtual void setState(int)=0;
    virtual int getState()=0;
private:
    vector<Observer*> vect;
protected:
    int state;
};

void Subject::attach(Observer* observer)
{
    vect.push_back(observer);
}

void Subject::detach(Observer* observer)
{
    vector<Observer*>::iterator ite = find(vect.begin(),vect.end(),observer);
    vect.erase(ite);
}

void Subject::notify()
{
    vector<Observer*>::iterator begin = vect.begin();
    while (begin != vect.end())
    {
        (*begin)->update(state);
        ++begin;
    }
}

class ConcreteObserver :public Observer
{
    void update(int);
};

void ConcreteObserver::update(int state)
{
    cout << this << " --->ConcreteObserver---------->" << state << endl;
}

class ConcreteSubject:public Subject
{
    void setState(int);
    int getState();
};

void ConcreteSubject::setState(int st)
{
    state = st;
}

int ConcreteSubject::getState()
{
    return state;
}


int main()
{
    Subject *subject = new ConcreteSubject();
    Observer *ob1 = new ConcreteObserver();
    Observer *ob2 = new ConcreteObserver();
    subject->attach(ob1);
    subject->attach(ob2);
    subject->setState(1);
    subject->notify();
    delete ob1;
    delete ob2;
    delete subject;
    system("pause");
    return 0;
}