c++设计模式：Observer 观察者模式

前期讲解：

观察者模式是使用频率最高的设计模式之一，它用于建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应作出反应。

在观察者模式中，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间可以没有任何相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展。

---

观察者模式的定义&特点：

观察者模式的定义：

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式是一种对象行为型模式

观察者模式特点：

观察者模式（Observer）完美的将观察者和被观察的对象分离开。举个例子，用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上

---

模式的优缺点：

观察者模式是一种对象行为型模式，其主要优点如下：

1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
2. 目标与观察者之间建立了一套触发机制。

它的主要缺点如下：

1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

---

观察者模式结构&实现：

结构图：

下面介绍图中包含的角色：

• Subject（目标）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标可以接受任意数量的观察者来观察，它提供一系列方法来增加和删除观察者对象，同时它定义了通知方法Notify()。目标类可以是接口，也可以是抽象类或具体类。
• ConcreteSubject（具体目标）：具体目标是目标类的派生类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法（如果有的话）。如果无须扩展目标类，则具体目标类可以省略。
• Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法update()，因此又称为抽象观察者。
• ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致；它实现了在抽象观察者Observer中定义的update()方法。通常在实现时，可以调用具体目标类的attach()方法将自己添加到目标类的集合中或通过detach()方法将自己从目标类的集合中删除
   

注意：
实现观察者模式的时候要注意，观察者和被观察对象之间的互动关系不能体现成类之间的直接调用，否则就将使观察者和被观察对象之间紧密的耦合起来，从根本上违反面向对象的设计的原则。无论是观察者“观察”观察对象，还是被观察者将自己的改变“通知”观察者，都不应该直接调用。

---

#include <iostream>
#include <list>
using namespace std;

/* 抽象观察者，提供update接口 */
class AbstractObserver
{
  public:
  virtual void update() = 0;
};

/*具体观察者，实现update接口*/
class Observe : public AbstractObserver
{
  /* 构造具体观察者，也可以单独写 */
	observer(string str, Object* obj) :name(str), ob(obj) {}
	
	void update();

	string getName()
	{
		return name;
	}
private:
	string name;
	Object* ob;
}

/* 抽象目标，提供抽象接口 */
class AbstractObject
{
   //删除观察者
   virtual Remove(Object* ob) = 0;
   //增加观察者
   virtual Add(Object* ob) = 0;
   //通知观察者
   virtual void Notify() = 0 
};

/*具体目标，实现抽象接口 */
class Object : public AbstractObject
{
    {
public:
	/* 添加指定观察者 */
	void Add(observer* ob)
	{
		observerList.push_back(ob);
	}

	/* 删除指定的观察者 */
	void Remove(observer* ob)
	{
		observerList.remove(ob);
	}

	/* 通知所有观察者 */
	void Notify()
	{
		auto it = observerList.begin();
		while (it != observerList.end())
		{
			(*it)->update();
			++it;
		}
	}

	string action;
private:
	list <observer*> observerList;
};

/* 观察者的update方法实现 */
void observer::update()
{
	cout << name << " : " << ob->action << endl;
}

int mian()
{
 /* 创建观察目标 */
	Object* p = new Object();

	/* 创建观察者 */
	observer* s1 = new observer("observer1", p);
	observer* s2 = new observer("observer2", p);
	observer* s3 = new observer("observer3", p);
	observer* s4 = new observer("observer4", p);

	/* 添加观察者到目标 */
	p->Add(s1);
	p->Add(s2);
	p->Add(s3);
	p->Add(s4);

	/* 事件产生 */
	p->action = "first update";

	/* 轮询通知 */
	p->Notify();

	/* 移除观察者s2 */
	p->Remove(s2);

	/* 事件产生 */
	p->action = "second update";

	/* 轮询通知 */
	p->Notify();
}

实例化：

#include <iostream>
#inlclde <list>
using namespace std;

//抽象观察者
class AbstractHero
{
  public:
  virtual void update() = 0;
};

//实现观察者1
class Hero1 : public AbstractHero
{
  public:
  Hero1()
  {
   cout << "Hero1 join" << endl;
  }
  void update()
  {
		cout << "Hero1 stop to attack Boss" << endl;
  }
};

//实现观察者2
class Hero2 : public AbstractHero
{
  public:
  Hero2()
  {
   cout << "Hero2 join" << endl;
  }
  void update()
  {
		cout << "Hero2 stop to attack Boss" << endl;
  }
};

//实现观察者3
class Hero3 : public AbstractHero
{
  public:
  Hero3()
  {
   cout << "Hero3 join" << endl;
  }
  void update()
  {
		cout << "Hero3 stop to attack Boss" << endl;
  }
};

//实现观察者4
class Hero4 : public AbstractHero
{
  public:
  Hero4()
  {
   cout << "Hero4 join" << endl;
  }
  void update()
  {
		cout << "Hero4 stop to attack Boss" << endl;
  }
};

//抽象目标
class AbstractBoss
{
public:
	/* 添加观察者 */
	virtual void Add(AbstractHero* hero) = 0;

	/* 删除观察者 */
	virtual void Remove(AbstractHero* hero) = 0;

	/* 通知所有观察者 */
	virtual void Notify() = 0;
};

//实现目标
class Boss : public AbstractBoss
{
 public:

 void Add(Abstracthero* hero)
 {
   heroList.push_back(hero);
 }
 
 void Remove(Abstracthero* hero)
 {
   heroList.remove(hero);
 }

 void Notify()
 {
  auto it = heroList.begin();
 
  while(it !=herList.end())
  {
    (*it)->update();
    ++it;
  }

 }
 
 private:
 list<AbstractHero> heroList;
}

int mian()
{
  /* 创建观察者：4位召唤师 */
  AbstractHero *hero1 = new hero1();
  AbstractHero *hero2 = new hero2();
  AbstractHero *hero3 = new hero3();
  AbstractHero *hero4 = new hero4();

  /* 创建目标：Boss */
  AbstractBoss* bossA = new Boss;

  /* 添加观察者到目标 */
  bossA->Add(hero1);
  bossA->Add(hero2);
  bossA->Add(hero3);
  bossA->Add(hero4);

  /* 移除观察者三号召唤师 */
  cout << endl << "Hero3 die, Remove Hero3" << endl << endl;
  bossA->Remove(hero3);

  /* 轮询通知 */ 
  cout << endl << "Boss die, Notify other heros" << endl << endl;
  bossA->Notify();
}

参考书籍《大话数据模式》程杰

参考文献：《http://c.biancheng.net/view/1390.html》