[设计模式C++]观察者模式

系列文章总结一些比较常见的设计模式，观察者模式在实际项目中也比较常见。例如游戏开发场景。

1 观察者模式的概念

    观察者(Observer) 模式又名发布-订阅( Publish/Subscribe)模式。GOF给观察者模式如下定义:定义对象间的- -种-对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

    举个例子随着交通信号灯的变化，汽车的行为也随之而变化，一盏交通信号灯可以指挥多辆汽车。

2 观察者模式的结构

1)抽象目标角色(Subject):目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。

2)抽象观察者角色(Observer):为那些在目标发生改变时需要获得通知的对象定义-一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。

3)具体目标角色(Concrete Subject):将有关状态存入各个Concrete Observer对象。当它的状态发生改变时，向它的各个观察者发出通知。

4)具体观察者角色(Concrete Observer):存储有关状态，这些状态应与目标的状态保持–致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护-一个指向Concrete Subject对象的引用。

3 实例实现

模拟打boss 当boss死亡通知所有英雄停止攻击…
代码中

1. 一个抽象boss 一个具体boss。
2. 一个抽象英雄 五个具体英雄。

boss类有三种方法 以及一个成员链表存放英雄

1. 添加英雄
2. 删除英雄
3. 通知所有英雄停止攻击。

# include<iostream>
using namespace std;
# include<list>
//抽象的英雄 抽象的观察者
class AbstractHero
{
   
public:
	virtual void Updata() = 0;
};
//具体的英雄 具体的观察者
class HeroA :public AbstractHero
{
   
public:
	HeroA() //创建就开始撸boss 等待命令停止
	{
   
		cout<<"A英雄正在撸boss...."<<endl;
	}
	void Updata()
	{
   
		cout<<"英雄A停止攻击，待机状态..."<<endl;
	}
};
//具体的英雄 具体的观察者
class HeroB :public AbstractHero
{
   
public:
	HeroB()
	{
   
		cout << "B英雄正在撸boss...." << endl;
	}
	void Updata()
	{
   
		cout << "英雄B停止攻击，待机状态..." << endl;
	}

};
//具体的英雄 具体的观察者
class HeroC :public AbstractHero
{
   
public:
	HeroC()
	{
   
		cout << "C英雄正在撸boss...." << endl;
	}
	void Updata()
	{
   
		cout << "英雄C停止攻击，待机状态..." << endl;
	}
};
//具体的英雄 具体的观察者
class HeroD :public AbstractHero
{
   
public:
	HeroD()
	{
   
		cout << "D英雄正在撸boss...." << endl;
	}
	void Updata()
	{
   
		cout << "英雄D停止攻击，待机状态..." << endl;
	}
};
//具体的英雄 具体的观察者
class HeroE :public AbstractHero
{
   
public:
	HeroE()
	{
   
		cout << "D英雄正在撸boss...." << endl;
	}
	void Updata()
	{
   
		cout << "英雄D停止攻击，待机状态..." << endl;
	}
};
//抽象的观察目标
class AbstractBoss
{
   
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero) = 0;

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

	//通知所以观察者
	virtual void notify() = 0;

};

//具体的观察目标
class BossA:public AbstractBoss
{
   
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero)
	{
   
		pHeroList.push_back(hero);
	}
	//删除观察者
	virtual void deleteHero(AbstractHero* hero)
	{
   
		pHeroList.remove(hero);
	}
	//通知所以观察者
	virtual void notify()
	{
   
		for (list<AbstractHero*>::iterator it = pHeroList.begin(); it!= pHeroList.end();it++)
		{
   
			(*it)->Updata();
		}
	}
	list<AbstractHero*> pHeroList;
};




int main()
{
   
	//创建观察者
	AbstractHero* heroA = new HeroA;
	AbstractHero* heroB = new HeroB;
	AbstractHero* heroC = new HeroC;
	AbstractHero* heroD = new HeroD;
	AbstractHero* heroE = new HeroE;
	//创建观察目标
	AbstractBoss* boss1 = new BossA;
	boss1->addHero(heroA);
	boss1->addHero(heroB);
	boss1->addHero(heroC);
	boss1->addHero(heroD);
	boss1->addHero(heroE);
	cout<<"heroc阵亡"<<endl;
	boss1->deleteHero(heroE);
	cout << "boss阵亡...通知其他英雄停止攻击" << endl;
	boss1->notify();


	return 0;
}

4 总结

    但我们遇到一个对象的状态发生改变时，所有依赖于它的对象都要更新变化就可以使用观察者模式，值得注意的是目标内的几个方法的实现。
    如有问题，欢迎指出。