观察者模式：
定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都得到通知并被自动更新。
它有四种角色：
主题（Subject）：一个接口，规定了具体主题需要实现的方法。
观察者（Observer）：也是一个接口，规定了具体观察者用来更新数据的方法。
具体主题：实现主题接口的一个实例，比如本例中的“就业通知中心”；里面会维护一个具体观察者的集合。本文使用STL中的list。
具体观察者：实现观察者的一个实例，会包含存放主题的引用或者指针。
使用C++实现如下:
包含5个文件，头文件两个：主题类（Subject.h）观察者类（Observer.h）
源文件两个：主题类（Subject.cpp）观察者类（Observer.h）
一个测试文件。
//Subject.h
#ifndef _SUBJECT_H_
#define _SUBJECT_H_
#include "Observer.h"
#include <list>
#include <string>
using namespace std;
class Observer;//注意C++中虽然包含了头文件这里也需要声明
typedef list<Observer*> myList;
class Subject{
public:
Subject(){}
virtual ~Subject(){}
virtual void addObserver(Observer* o) = 0;
virtual void deleteObserver(Observer* o) = 0;
virtual void notifyObservers() = 0;
};
class SeekJobCenter : public Subject
{
public:
SeekJobCenter();
~SeekJobCenter(){}
void addObserver(Observer* o);
void deleteObserver(Observer* o);
void notifyObservers();
void giveNewMessage(string str);
private:
string mess;
bool changed;
myList personList;
};
#endif
//Subject.cpp
//具体的主题
#include "stdafx.h"
#include "Subject.h"
#include "Observer.h"
#include <list>
SeekJobCenter::SeekJobCenter()
{
mess = "";
changed = false;
}
void SeekJobCenter::addObserver(Observer* o)
{
list<Observer*>::iterator it;
//判断原始维护的list中是否存在添加的对象
it = find(personList.begin(), personList.end(), o);
if (it == personList.end())//不存在
{
personList.push_back(o);
}
return;
}
void SeekJobCenter::deleteObserver(Observer* o)
{
list<Observer*>::iterator it;
it = find(personList.begin(), personList.end(), o);
if (it != personList.end())//存在
{
personList.remove(*it);
delete(*it);
}
return;
}
void SeekJobCenter::notifyObservers()
{
list<Observer*>::iterator it;
if (changed)
{
for (it = personList.begin(); it != personList.end(); ++it)
{
(*it)->hearTelephone(mess);
}
changed = false;
}
return;
}
void SeekJobCenter::giveNewMessage(string str)
{
if (0 == strcmp(str.c_str(), mess.c_str()))
{
changed = false;
}
else
{
mess = str;
changed = true;
}
return;
}
//Observer.h
#ifndef _OBSERVER_H_
#define _OBSERVER_H_
#include <string>
#include <iostream>
#include <list>
#include "Subject.h"
using namespace std;
class Subject;
/*
观察者基类
*/
class Observer
{
public:
Observer(){};
virtual ~Observer(){};
virtual void hearTelephone(string heardMess) = 0;
};
class UniversityStudent : public Observer
{
public:
UniversityStudent(Subject* subject);
virtual ~UniversityStudent(){};
void hearTelephone(string heardMess);
private:
Subject* subject;
};
class HaiGui : public Observer
{
public:
HaiGui(Subject *subject);
virtual ~HaiGui(){};
void hearTelephone(string heardMess);
private:
Subject *subject;
};
#endif
//Observer.cpp
#include "stdafx.h"
#include "Observer.h"
#include "Subject.h"
UniversityStudent::UniversityStudent(Subject* subject)
{
if (NULL != subject)
{
this->subject = subject;
}
else
{
return;
}
subject->addObserver(this);
}
void UniversityStudent::hearTelephone(string heardMess)
{
std::cout << "I am a university student" << std::endl;
std::cout << "I hear message is " << heardMess << std::endl;
return;
}
HaiGui::HaiGui(Subject* subject)
{
if (NULL != subject)
{
this->subject = subject;
}
else
{
return;
}
subject->addObserver(this);
}
void HaiGui::hearTelephone(string heardMess)
{
std::cout << "I am a HaiGui" << std::endl;
std::cout << "I hear message is " ;
cout << heardMess << endl;
return;
}
最后一个测试的文件：
#include "stdafx.h"
#include "Observer.h"
#include "Subject.h"
int _tmain(int argc, _TCHAR* argv[])
{
SeekJobCenter *center = new SeekJobCenter();
UniversityStudent *chengchaolee = new UniversityStudent(center);
HaiGui *haigui = new HaiGui(center);
center->giveNewMessage("I need a cook");
center->notifyObservers();
center->giveNewMessage("I need a xxxx");
center->notifyObservers();
delete center;
delete chengchaolee;
delete haigui;
return 0;
}
定义两个具体的观察者，并且以具体主题作为参数，代表它观察的对象，然后当主题推送数据时，观察者就会收到消息，即“推数据”的方式，当然还有一种观察者模式采用的是拉数据，即由观察者自己定义需要什么数据，主题在notify的时候并不传递参数而是在观察者更新数据时，将Subject向下转换为具体Subject，从而获取其中相应的数据，这种方式叫做“拉数据”。
值得注意的是，C++在实现的时候，采用list存储具体观察者，需要使用list<Observer*>类型，即使用指针。不然会编译不通过，因为Observer是虚基类，无法实例化。
原文：http://www.cnblogs.com/leewhite/p/6027421.html