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

UML结构图：

解析：

Observer模式定义的是一种一对多的关系，这里的一就是图中的Subject类，而多则是Obesrver类，当Subject类的状态发生变化的时候通知与之对应的Obesrver类们也去相应的更新状态，同时支持动态的添加和删除Observer对象的功能。Obesrver模式的实现要点是，第一一般subject类都是采用链表等容器来存放Observer对象，第二抽取出Observer对象的一些公共的属性形成Observer基类，而Subject中保存的则是Observer类对象的指针，这样就使Subject和具体的Observer实现了解耦，也就是Subject不需要去关心到底是哪个Observer对放进了自己的容器中。生活中有很多例子可以看做是Observer模式的运用，比方说，一个班有一个班主任（Subject），他管理手下的一帮学生（Observer），当班里有一些事情发生需要通知学生的时候，班主任要做的不是逐个学生挨个的通知而是把学生召集起来一起通知，实现了班主任和具体学生的关系解耦。

实现：

1）Observer.h

/**//********************************************************************
　　　 created:　　　 2006/07/20
　　　 filename:　　　　 Observer.h
　　　 author:　　　　　　　 李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Observer模式的演示代码
*********************************************************************/

#ifndef OBSERVER_H
#define OBSERVER_H

#include <list>

typedef int STATE;

class Observer;

// Subject抽象基类,只需要知道Observer基类的声明就可以了
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指针的链表
};

// Observer抽象基类
class Observer
{
public:
　　　 Observer() : m_nObserverState(-1){}
　　　 virtual ~Observer(){}

　　　 // 纯虚函数,各个派生类可能有不同的实现
　　　 // 通知Observer状态发生了变化
　　　 virtual void Update(Subject* pSubject) = 0;

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

// ConcreateSubject类,派生在Subject类
class ConcreateSubject
　　　 : public Subject
{
public:
　　　 ConcreateSubject() : Subject(){}
　　　 virtual ~ConcreateSubject(){}

　　　 // 派生类自己实现来覆盖基类的实现
　　　 virtual void　　　 SetState(STATE nState);　　　 // 设置状态
　　　 virtual STATE　　　 GetState();　　　　　　　 // 得到状态

};

// ConcreateObserver类派生自Observer
class ConcreateObserver
　　　 : public Observer
{
public:
　　　 ConcreateObserver() : Observer(){}
　　　 virtual ~ConcreateObserver(){}

　　　 // 虚函数,实现基类提供的接口
　　　 virtual void Update(Subject* pSubject);
};

#endif

/**//********************************************************************
　　　 created:　　　 2006/07/20
　　　 filename:　　　　 Observer.cpp
　　　 author:　　　　　　　 李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Observer模式的演示代码
*********************************************************************/

#include "Observer.h"
#include <iostream>
#include <algorithm>

/**//* --------------------------------------------------------------------
|　　　 Subject类成员函数的实现
|
　----------------------------------------------------------------------*/

void Subject::Attach(Observer *pObserver)
{
　　　 std::cout << "Attach an Observern";

　　　 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 Observern";
}

void Subject::Notify()
{
　　　 std::cout << "Notify Observers''s Staten";

　　　 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 Subjectn";
　　　 m_nSubjectState = nState;
}

STATE Subject::GetState()
{
　　　 std::cout << "GetState By Subjectn";
　　　 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 ConcreateSubjectn";
　　　 m_nSubjectState = nState;
}

STATE ConcreateSubject::GetState()
{
　　　 std::cout << "GetState By ConcreateSubjectn";
　　　 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;
}

/**//********************************************************************
　　　 created:　　　 2006/07/21
　　　 filename:　　　　 Main.cpp
　　　 author:　　　　　　　 李创
　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/

　　　 purpose:　　　 Observer模式的测试代码
*********************************************************************/

#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;

　　　 system("pause");

　　　 return 0;
}

    UML结构图：

    抽象基类：

    1）Component：为组合中的对象声明接口，声明了类共有接口的缺省行为（如这里的Add，Remove，GetChild函数），声明一个接口函数可以访问Component的子组件。

    接口函数：

    1）Component：：Operatation：定义了各个组件共有的行为接口，由各个组件的具体实现。

    2）Component：：Add添加一个子组件

    3）Component：：Remove：：删除一个子组件。

    4）Component：：GetChild：获得子组件的指针。

    解析：

    Component模式是为解决组件之间的递归组合提供了解决的办法，它主要分为两个派生类，其中的Leaf是叶子结点，也就是不含有子组件的结点，而Composite是含有子组件的类。举一个例子来说明这个模式，在UI的设计中，最基本的控件是诸如Button，Edit这样的控件，相当于是这里的Leaf组件，而比较复杂的控件比如List则可也看做是由这些基本的组件组合起来的控件，相当于这里的Composite，它们之间有一些行为含义是相同的，比如在控件上作一个点击，移动操作等等的，这些都可以定义为抽象基类中的接口虚函数，由各个派生类去实现之，这些都会有的行为就是这里的Operation函数，而添加，删除等进行组件组合的操作只有非叶子结点才可能有，所以虚拟基类中只是提供接口而且默认的实现是什么都不做。

    1）Composite.h

/**//******************************************************************** 　　　 created:　　　 2006/07/20 　　　 filename:　　　　 Composite.h 　　　 author:　　　　　　　 李创 　　　　　　　　　　　　　　　 http://www.cppblog.com/converse/ 　　　 purpose:　　　 Composite模式的演示代码 *********************************************************************/ #ifndef COMPOSITE_H #define COMPOSITE_H #include <list> // 组合中的抽象基类 class Component { public: 　　　 Component(){} 　　　 virtual ~Component(){} 　　　 // 纯虚函数,只提供接口,没有默认的实现 　　　 virtual void Operation() = 0; 　　　 // 虚函数,提供接口,有默认的实现就是什么都不做 　　　 virtual void Add(Component* pChild); 　　　 virtual void Remove(Component* pChild); 　　　 virtual Component* GetChild(int nIndex); }; // 派生自Component,是其中的叶子组件的基类 class Leaf 　　　 : public Component { public: 　　　 Leaf(){} 　　　 virtual ~Leaf(){} 　　　 virtual void Operation(); }; // 派生自Component,是其中的含有子件的组件的基类 class Composite 　　　 : public Component { public: 　　　 Composite(){} 　　　 virtual ~Composite(); 　　　 virtual void Operation(); 　　　 virtual void Add(Component* pChild); 　　　 virtual void Remove(Component* pChild); 　　　 virtual Component* GetChild(int nIndex); private: 　　　 // 采用list容器去保存子组件 　　　 std::list<Component*>　　　 m_ListOfComponent; }; #endif