c++设计模式，观察者模式理解及demo实现

Observer模式要解决的问题为：建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，依赖这个“一”的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，我们希望能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计的显示都能够同时改变。Observer模式就是解决了这一个问题。

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

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

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

 

#pragma once
#include <list>
#include <string>
using namespace std;
typedef string State;
class Observer;
class Subject
{
public:
    virtual ~Subject();
    virtual void Attach(Observer* obv);
    virtual void Detach(Observer* obv);
    virtual void Notify();
    virtual void SetState(const State& st)=0;
    virtual State GetState()=0;
protected:
    Subject();
private:
    list<Observer* >* _obvs;
};
class ConcreteSubject:public Subject
{
public:
    ConcreteSubject();
    ~ConcreteSubject();
    State GetState();
    void SetState(const State& st);
protected:
private:
    State _st;

}；

typedef string State;
class Observer
{
public:
    virtual ~Observer();
    virtual void Updata(Subject* sub)=0;
    virtual void PrintInfo()=0;
protected:
    Observer();
    State _st;
private:
};
class ConcreteObserverA:public Observer
{
public:
    virtual Subject* GetSubject();
    ConcreteObserverA(Subject* sub);
    virtual ~ConcreteObserverA();
    void Updata(Subject* sub);
    void PrintInfo();
protected:
private:
    Subject* _sub;
};
class ConcreteObserverB:public Observer
{
public:
    virtual Subject* GetSubject();
    ConcreteObserverB(Subject* sub);
    virtual ~ConcreteObserverB();
    void Updata(Subject* sub);
    void PrintInfo();
protected:
private:
    Subject* _sub;
};

Subject::Subject()
{
    _obvs=new list<Observer* >;
}
Subject::~Subject()
{

}
void Subject::Attach(Observer* obv)
{
    _obvs->push_front(obv);
}
void Subject::Detach(Observer* obv)
{
    if (obv!=NULL)
    {
        _obvs->remove(obv);
    }
}
void Subject::Notify()
{
    list<Observer* >::iterator it;
    it=_obvs->begin();
    for(;it!=_obvs->end();it++)
    {
        (*it)->Updata(this);
    }
}
ConcreteSubject::ConcreteSubject()
{
    _st='\0';
}
ConcreteSubject::~ConcreteSubject()
{

}
state ConcreteSubject::GetState()
{
    return _st;
}
void ConcreteSubject::SetState(const State& st)
{
    _st=st;
}

Observer::Observer()
{
    _st='\0';
}
Observer::~Observer()
{

}
ConcreteObserverA::ConcreteObserverA(Subject* sub)
{
    _sub=sub;
    _sub->Attach(this);
}
ConcreteObserverA::~ConcreteObserverA()
{
    _sub->Detach(this);
    if (_sub!=0)
    {
        delete _sub;
    }
}
Subject* ConcreteObserverA::GetSubject()
{
    return _sub;
}
void ConcreteObserverA::PrintInfo()
{
    cout<<"ConcreteObserverA observer......"<<_sub->GetState()<<endl;
}
void ConcreteObserverA::Updata(Subject* sub)
{
    _st=sub->GetState();
    PrintInfo();
}
ConcreteObserverB::ConcreteObserverB(Subject* sub)
{
    _sub=sub;
    _sub->Attach(this);
}
ConcreteObserverB::~ConcreteObserverB()
{
    _sub->Detach(this);
    if (_sub!=0)
    {
        delete _sub;
    }
}
Subject* ConcreteObserverB::GetSubject()
{
    return _sub;
}
void ConcreteObserverB::PrintInfo()
{
    cout<<"ConcreteObserverB observer....."<<_sub->GetState()<<endl;
}
void ConcreteObserverB::Updata(Subject* sub)
{
    _st=sub->GetState();
    PrintInfo();
}

int main()
{
    ConcreteSubject* sub=new ConcreteSubject();
    Observer* o1=new ConcreteObserverA(sub);
    Observer* o2=new ConcreteObserverB(sub);
    sub->SetState("old");
    sub->Notify();
    sub->SetState("new");
    sub->Notify();
    return 0;
}