观察者模式

介绍

观察者模式（有时又被称为发布（publish ）-订阅（Subscribe）模式、模型-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

UML结构图

作用

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

实现

Observer.h

#ifndef OBSERVER_H
#define OBSERVER_H

#include <list>

typedef int STATE;

class Observer;

class Subject
{
public:
    Subject() :m_nSubjectState(-1) {}
    virtual ~Subject();

    void Notify();
    void Attach(Observer *pObserver);
    void Detach(Observer *pObserver);

    virtual void SetState(STATE nState);
    virtual STATE GetState();
protected:
    STATE m_nSubjectState;
    std::list<Observer*> m_ListObserver;
};

class Observer
{
public:
    Observer() :m_nObserverState(-1) {}
    virtual ~Observer() {}

    virtual void Update(Subject* pSubject) = 0;

protected:
    STATE m_nObserverState;
};


class ConcreateSubject:public Subject
{
public:
    ConcreateSubject() :Subject() {};
    virtual ~ConcreateSubject() {};

    virtual void SetState(STATE nState);
    virtual STATE GetState();
};

class ConcreateObserver:public Observer
{
public:
    ConcreateObserver() :Observer() {};
    virtual ~ConcreateObserver() {};

    virtual void Update(Subject* pSubject);

};

#endif

Observer.cpp

#include "Observer.h"
#include <iostream>
#include <algorithm>

/************Subject类成员函数的实现************/
void Subject::Attach(Observer *pObserver)
{
    std::cout << "添加一个观察者" << std::endl;
    m_ListObserver.push_back(pObserver);
}

void Subject::Detach(Observer *pObserver)
{
    std::list<Observer*>::iterator it;
    it = std::find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);

    if (m_ListObserver.end() != it)
    {
        m_ListObserver.erase(it);
    }
    std::cout << "删除一个观察者" << std::endl;
}

void Subject::Notify()
{
    std::cout << "通知观察者状态改变" << std::endl;
    std::list<Observer*>::iterator it1, it2;

    for (it1=m_ListObserver.begin(),it2=m_ListObserver.end(); 
        it1!=it2; ++it1)
    {
        (*it1)->Update(this);
    }
}

void Subject::SetState(STATE nState)
{
    std::cout << "设置状态(Subject)" << std::endl;
    m_nSubjectState = nState;
}

STATE Subject::GetState()
{
    std::cout << "获取状态(Subject)" << std::endl;
    return m_nSubjectState;
}

Subject::~Subject()
{
    std::list<Observer*>::iterator it1, it2, temp;

    for (it1 = m_ListObserver.begin(), it2 = m_ListObserver.end();
    it1 != it2;)
    {
        temp = it1;
        ++it1;
        delete(*temp);
    }

    m_ListObserver.clear();
}

/************ConcreateSubject类成员函数的实现************/
STATE ConcreateSubject::GetState()
{
    std::cout << "获取状态(ConcreateSubject)" << std::endl;
    return m_nSubjectState;
}

void ConcreateSubject::SetState(STATE nState)
{
    std::cout << "设置状态(ConcreateSubject)" << std::endl;
    m_nSubjectState = nState;
}

/************ConcreateObserver类成员函数的实现************/
void ConcreateObserver::Update(Subject* pSubject)
{
    if (pSubject == NULL)
    {
        return;
    }

    m_nObserverState = pSubject->GetState();

    std::cout << "观察者的状态是:" << m_nObserverState << std::endl;
}

main

int main()
{
    Observer *p1 = new ConcreateObserver;
    Observer *p2 = new ConcreateObserver;

    Subject* p = new ConcreateSubject;
    p->Attach(p1);
    Sleep(2000);
    p->Attach(p2);
    Sleep(2000);
    p->SetState(4);
    Sleep(2000);
    p->Notify();
    Sleep(2000);

    p->Detach(p1);
    Sleep(2000);
    p->SetState(10);
    Sleep(2000);
    p->Notify();

    delete p;
    system("pause");
    return 0;
}

截图