Observer模式

    1、问题

    Observer模式要解决的问题是：建立一个“一”对“多”的依赖关系。当这个“一”发生变化的时候，依赖这个“一”的“多”也能同时改变。这里中，“一”即是Subject，“多”即是Observer。

    举个简单的例子：同一组数据能够以表格、柱状图、百分比的形式来表示。当然这些表示形式都依赖于这一组数据，当这一组数据改变的时候，这些表示形式也要做相应的改变。

 

    2、结构图

 

    3、Code --C++

 

// observer.h
#ifndef OBSERVER_H
#define OBSERVER_H

#include <list>
typedef int STATE;

class Observer;

// Subject 抽象基类
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;               // 模拟保存Subject状态的变量
    std::list<Observer*> m_ListObserver; // 保存Observer指针的链表
};
// Subject 派生类
class ConcreateSubject : public Subject
{
public:
    ConcreateSubject() : Subject(){}
    virtual ~ConcreateSubject(){}

    virtual void SetState(STATE nState); // 设置状态
    virtual STATE GetState();            // 得到状态
};

// Observer 抽象基类
class Observer
{
public:
    Observer() : m_nObserverState(-1){}
    virtual ~Observer(){}
    
    virtual void Update(Subject* pSubject) = 0; // 通知Observer状态发生了变化

protected:
    STATE m_nObserverState;                     // 模拟保存Observer状态的变量
};

// Observer 派生类
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 << "Attach an Observer\n";
    m_ListObserver.push_back(pObserver);
}
void Subject::Detach(Observer *pObserver)
{
    std::list<Observer*>::iterator iter;
    iter = std::find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);
    if (m_ListObserver.end() != iter)
    {
        m_ListObserver.erase(iter);
    }
    std::cout << "Detach an Observer\n";
}
void Subject::Notify()
{
    std::cout << "Notify Observers's State\n";
    std::list<Observer*>::iterator iter1, iter2;
    for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();
        iter1 != iter2;
        ++iter1)
    {
        (*iter1)->Update(this);
    }
}
void Subject::SetState(STATE nState)
{
    std::cout << "SetState By Subject\n";
    m_nSubjectState = nState;
}

STATE Subject::GetState()
{
    std::cout << "GetState By Subject\n";
    return m_nSubjectState;
}
Subject::~Subject()
{
    std::list<Observer*>::iterator iter1, iter2, temp;
    for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();
        iter1 != iter2;
        )
    {
        temp = iter1;
        ++iter1;
        delete (*temp);
    }
    m_ListObserver.clear();
}

// ConcreateSubject类
void ConcreateSubject::SetState(STATE nState)
{
    std::cout << "SetState By ConcreateSubject\n";
    m_nSubjectState = nState;
}
STATE ConcreateSubject::GetState()
{
    std::cout << "GetState By ConcreateSubject\n";
    return m_nSubjectState;
}

// ConcreateObserver类
void ConcreateObserver::Update(Subject* pSubject)
{
    if (NULL == pSubject)
        return;
    m_nObserverState = pSubject->GetState();
    std::cout << "The ObeserverState is " << m_nObserverState << std::endl;
}

// main.cpp
#include "Observer.h"
#include <iostream>
int main()
{
    Observer *p1 = new ConcreateObserver;
    Observer *p2 = new ConcreateObserver;
    Subject* p = new ConcreateSubject;
    p->Attach(p1);
    p->Attach(p2);
    p->SetState(4);
    p->Notify();
    p->Detach(p1);
    p->SetState(10);
    p->Notify();
    delete p;
    return 0;
}