Observer模式是开发中,使用比较多的模式之一.Observer模式叫做观察者模式,它定义了一种一对多的依赖模式,让多个观察者同时监听某一对象状态,当这个对象状态发生变化时,这些观察者都得到通知.
下图即为Observer模式的类图:
实现如下:
//Subject.h
//Subject.h
#ifndef _SUBJECT_H_
#define _SUBJECT_H_
#include <string>
#include <boost/ptr_container/ptr_container.hpp>
typedef std::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:
boost::ptr_vector<Observer> obvs_;
};
class ConcreteSubject : public Subject
{
public:
ConcreteSubject();
~ConcreteSubject();
State GetState();
void SetState(const State& st);
private:
State st_;
};
#endif
//Subject.cpp
//Subject.cpp
#include "Subject.h"
#include "Observer.h"
#include <iostream>
Subject::Subject()
{
}
Subject::~Subject()
{
}
void Subject::Attach(Observer* obv)
{
obvs_.push_back(obv);
}
void Subject::Detach(Observer* obv)
{
for(boost::ptr_vector<Observer>::iterator iter=obvs_.begin(); iter!=obvs_.end(); ++iter)
{
if(obv==&(*iter))
{
obvs_.erase(iter);//dead loop????
break;
}
}
return ;
}
void Subject::Notify()
{
for(boost::ptr_vector<Observer>::iterator iter=obvs_.begin(); iter!=obvs_.end(); ++iter)
{
iter->Update(this);
}
}
ConcreteSubject::ConcreteSubject()
{
st_='\0';
}
ConcreteSubject::~ConcreteSubject()
{
}
void ConcreteSubject::SetState(const State& st)
{
st_=st;
}
State ConcreteSubject::GetState()
{
return st_;
}
//Observer.h
#ifndef _OBSERVER_H_
#define _OBSERVER_H_
#include "Subject.h"
#include <string>
typedef std::string State;
class Observer
{
public:
virtual ~Observer();
virtual void Update(Subject* sub)=0;
virtual void PrintInfo()=0;
protected:
Observer();
State st_;
};
class ConcreteObserverA:public Observer
{
public:
virtual ~ConcreteObserverA();
ConcreteObserverA(Subject* sub);
virtual Subject* GetSubject();
void Update(Subject* sub);
void PrintInfo();
private:
Subject* sub_;
};
class ConcreteObserverB:public Observer
{
public:
virtual ~ConcreteObserverB();
ConcreteObserverB(Subject* sub);
virtual Subject* GetSubject();
void Update(Subject* sub);
void PrintInfo();
private:
Subject* sub_;
};
#endif //_OBSERVER_H_
//Observer.cpp
//Observer.cpp
#include "Observer.h"
#include "Subject.h"
#include <iostream>
#include <string>
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()
{
std::cout<<"ConcreteObserverA observer "<<st_<<std::endl;
}
void ConcreteObserverA::Update(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()
{
std::cout<<"ConcreteObserverB observer "<<st_<<std::endl;
}
void ConcreteObserverB::Update(Subject* sub)
{
st_=sub->GetState();
PrintInfo();
}
//main.cpp
#include "Subject.h"
#include "Observer.h"
int main()
{
ConcreteSubject* sub=new ConcreteSubject();
Observer* o1=new ConcreteObserverA(sub);
Observer* o2=new ConcreteObserverB(sub);
sub->SetState("old");
sub->Notify();
sub->Detach(o1);
sub->SetState("new");
sub->Notify();
return 0;
}