大话设计模式--观察者模式 Observer -- C++ 实现实例

大话设计模式--1.观察者模式： 定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有的

观察者对象，使他们能够自动更新自己。



使用场合：

当一个对象的改变需要同时改变其他对象时，而且它不知道具体有多少对象有待改变。

当一个抽象模型有两个方面，其中一个方面依赖另一个方面，这时观察者模式可以使这两者封装在独立的对象中使它们各自独立地改变和复用。

缺点： 抽象通知者 还是依赖于 抽象观察者，并不是一定能抽象出观察者这样的接口，并且每个具体的观察者并不一定是以update的方法调用，

依靠委托解决以上问题。



实例：

subject.h subject.cpp 通知者抽象

#ifndef SUBJECT_H
#define SUBJECT_H

#include "Observer.h"
#include <list>
using namespace std;

class Subject
{
public:
Subject();
void virtual addObserver(Observer *observer);
void virtual delObserver(Observer *observer);
void virtual notify();

private:
list<Observer*> *observer;
};

#endif // SUBJECT_H

#include "subject.h"

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

void Subject::addObserver(Observer* observer)
{
this->observer->push_back(observer);
}

void Subject::delObserver(Observer* observer)
{

}

void Subject::notify()
{
Observer *ob;
list<Observer*>::iterator i;
for(i=observer->begin(); i!=observer->end(); i++)
{
ob = *i;
ob->update();

}
}

concretesubject.h concretesubject.cpp 通知者实例

#ifndef CONCRETESUBJECT_H
#define CONCRETESUBJECT_H

#include "subject.h"
#include <string>
using namespace std;

class concreteSubject : public Subject
{
public:
concreteSubject();
void setSubjectState(string state);
string getSubjectState();

private:
string subjectState;
};

#endif // CONCRETESUBJECT_H

#include "concretesubject.h"

concreteSubject::concreteSubject()
{
}

void concreteSubject::setSubjectState(string state)
{
subjectState = state;
}

string concreteSubject::getSubjectState()
{
return subjectState;
}

observer.h observer.cpp 观察者抽象

#ifndef OBSERVER_H
#define OBSERVER_H

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

#endif // OBSERVER_H

#include "observer.h"

Observer::Observer()
{
}

void Observer::update()
{

}

concreteobserver1.h concreteobserver1.cpp 观察者实例

#ifndef CONCRETEOBSERVER1_H
#define CONCRETEOBSERVER1_H

#include "observer.h"
#include "concretesubject.h"
#include <string>
using namespace std;

class ConcreteObserver1 : public Observer
{
public:
ConcreteObserver1(concreteSubject *subject, string name);
void update();

private:
string name;
string observerState;
concreteSubject* subject;

};

#endif // CONCRETEOBSERVER1_H

#include "concreteobserver1.h"
#include <iostream>
using namespace std;

ConcreteObserver1::ConcreteObserver1(concreteSubject *subject, string name)
{
this->subject = subject;
this->name = name;
observerState = subject->getSubjectState();
}

void ConcreteObserver1::update()
{
observerState = subject->getSubjectState();
cout << "name: " << name << " ,state: " << observerState << endl;
}

main.cpp

#include <iostream>
#include "concreteobserver1.h"
#include "concretesubject.h"
using namespace std;

int main()
{
cout << "Observer test !" << endl;

concreteSubject s;
s.addObserver(new ConcreteObserver1(&s, "zhangsan"));
s.addObserver(new ConcreteObserver1(&s, "lisi"));
s.setSubjectState("boss comes back");
s.notify();

return 0;
}