C++设计模式（三）之策略模式、命令模式、观察者模式

C++设计模式之策略模式

//抽象武器 武器策略
class WeaponStrategy {
public:
	virtual void useWeapon() = 0;
};

//武器:刀
class Knife : public WeaponStrategy
{
public:
	virtual void useWeapon()
	{
		cout << "使用匕首" << endl;
	}
};
//武器:Ak47
class Ak47 : public WeaponStrategy
{
public:
	virtual void useWeapon()
	{
		cout << "使用Ak47" << endl;
	}
};

class Hero {
public:
	void setWeapon(WeaponStrategy *weapon)
	{
		this->weapon = weapon;
	}

	void throwWeapon()
	{
		this->weapon->useWeapon();
	}
private:
	WeaponStrategy* weapon;
};

int main()
{
	//创建角色
	Hero* hero = new Hero;

	//武器策略
	WeaponStrategy* knife = new Knife;
	WeaponStrategy* ak47 = new Ak47;
	hero->setWeapon(knife);
	hero->throwWeapon();

	hero->setWeapon(ak47);
	hero->throwWeapon();
	delete knife;
	delete ak47;
	delete hero;
}

C++设计模式之命令模式
命令模式：将一个请求封装为一个对象，让我们可以用不同的请求对客户进行参数化。对请求排队或者记录请求日志，以及支持可撤销的 *** 作。命令模式是一种对象行为模式，其别名为动作或事务模式。
命令模式可以将请求发送者和接收者完全解构，发送者和接受者之间没有直接引用关系，发送请求的对象只需要直到如何发送请求，而不必知道如何完成请求。

例子： 客户端(clinet)需要发送各种请求给服务端（server），server需要依次有序处理各种请求

//客户端协议处理类
class HandleProtocl {
public:
	void addMoney()
	{
		cout << "添加金钱" << endl;
	}
	void addEquiment()
	{
		cout << "添加设备" << endl;
	}
};

//抽象命令
class AbstractCommand {
public:
	virtual void handle() = 0;
};

//添加金钱命令行
class AddMoneyCommand : public AbstractCommand
{
public:
	AddMoneyCommand(HandleProtocl* protocol)
	{
		this->protocol = protocol;
	}
	void handle()
	{
		this->protocol->addMoney();
	}
private:
	HandleProtocl* protocol;
};

//添加装备命令行
class AddEquimentCommand : public AbstractCommand
{
public:
	AddEquimentCommand(HandleProtocl* protocol)
	{
		this->protocol = protocol;
	}
	void handle()
	{
		this->protocol->addEquiment();
	}
private:
	HandleProtocl* protocol;
};

class Server {
public:
	void addRequest(AbstractCommand* commond)
	{
		qCommand.push(commond);
	}

	void startHandle()
	{
		while (!qCommand.empty())
		{
			AbstractCommand* commond = qCommand.front();
			commond->handle();
			qCommand.pop(); //处理过的请求从队列队头中去d出
		}
	}
private:
	queue<AbstractCommand*> qCommand;
};

int main()
{
	HandleProtocl* protocol = new HandleProtocl;
	AbstractCommand* addMoney = new AddMoneyCommand(protocol);
	AbstractCommand* addEquiment = new AddEquimentCommand(protocol);

	Server* server = new Server;
	server->addRequest(addMoney);
	server->addRequest(addEquiment);

	//服务端开始处理请求
	server->startHandle();
}

C++设计模式之观察者模式

背景： 交通灯和车辆的场景，当交通灯发生改变，汽车的行为也随之发生改变

观察者模式是用于建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应作出反应。 在观察者模式中，发生改变的对象的称为观察目标，而被通知的对象称为观察者。一个观察目标可以对应多个观察者。

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

//具体观察者
class HeroA : public AbstractHero {
public:
	HeroA()
	{
		cout << "英雄A正在打Boss..." << endl;
	}
	void update()
	{
		cout << "英雄A停止攻击..." << endl;
	}
};

class HeroB : public AbstractHero {
public:
	HeroB()
	{
		cout << "英雄B正在打Boss..." << endl;
	}
	void update()
	{
		cout << "英雄B停止攻击..." << endl;
	}
};

//观察目标抽象
class AbstractBoss {
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero) = 0;
	//删除观察者
	virtual void delHero(AbstractHero* hero) = 0;
	//通知所有观察者
	virtual void notify() = 0;
};

//具体的观察目标对象
class BossA : public AbstractBoss {
public:
	void addHero(AbstractHero* hero)
	{
		pHeroList.push_back(hero);
	}
	void delHero(AbstractHero* hero)
	{
		pHeroList.remove(hero);
	}
	void notify()
	{
		for (auto it = pHeroList.begin(); it != pHeroList.end(); it++)
		{
			(*it)->update();
		}
	}
private:
	list<AbstractHero*> pHeroList;
};

void test01()
{
	//创建观察者
	AbstractHero* heroA = new HeroA;
	AbstractHero* heroB = new HeroB;

	//创建观察目标
	AbstractBoss* bossA = new BossA;
	bossA->addHero(heroA);
	bossA->addHero(heroB);

	cout << "heroB阵亡" << endl;
	bossA->delHero(heroB);

	cout << "Boss死了， 通知其他英雄停止攻击" << endl;
	bossA->notify();
}