目录
一、模板方法模式
定义一个操作中算法的框架,而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
类别 | 描述 |
适用场景 |
|
优点 |
|
缺点 |
|
#include <iostream>
using namespace std;
class DrinkTemplate {
public:
//注水
virtual void Boildwater() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加辅助料
virtual void AddSomething() = 0;
//模板方法
void Make() {
Boildwater();
Brew();
PourInCup();
AddSomething();
}
};
//冲泡咖啡
class Coffee : public DrinkTemplate {
public:
//注水
virtual void Boildwater() {
cout << "煮山泉水..." << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡咖啡..." << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "咖啡倒入杯中..." << endl;
}
//加辅助料
virtual void AddSomething() {
cout << "加糖,加牛奶,加点醋..." << endl;
}
};
//冲泡咖啡
class Tea : public DrinkTemplate {
public:
//注水
virtual void Boildwater() {
cout << "煮自来水..." << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡铁观音..." << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "茶水倒入杯中..." << endl;
}
//加辅助料
virtual void AddSomething() {
cout << "加糖,加柠檬,加生姜..." << endl;
}
};
int main() {
DrinkTemplate* tea = new Tea;
tea->Make();
cout << "----------------" << endl;
DrinkTemplate* coffee = new Coffee;
coffee->Make();
delete tea;
delete coffee;
return 0;
}
二、命令模式
将一个请求封装为一个对象,从而让我们可用不同的请求对客户进行参数化。
将请求发送者和接收者完全解耦,发送者与接收者之间没有直接引用关系,发送请求的对象只需要知道如何发送请求,而不必知道如何完成请求。
类别 | 描述 |
适用场景 |
|
优点 |
|
缺点 |
|
#include <iostream>
#include <queue>
#include <Windows.h>
using namespace std;
//协议处理类
class HandleClientProtocol {
public:
//处理增加金币
void AddMoney() {
cout << "给玩家增加金币!" << endl;
}
//处理增加钻石
void AddDiamod() {
cout << "给玩家增加钻石!" << endl;
}
//处理玩家装备
void AddEquipment() {
cout << "给玩家穿装备!" << endl;
}
//处理玩家升级
void AddLevel() {
cout << "给玩家升级!" << endl;
}
};
//命令接口
class AbstractCommand {
public:
virtual void handle() = 0; //处理客户端请求的接口
};
//处理增加金币请求
class AddMoneyCommand :public AbstractCommand {
public:
AddMoneyCommand(HandleClientProtocol* protocol) {
this->pProtocol = protocol;
}
virtual void handle() {
this->pProtocol->AddMoney();
}
public:
HandleClientProtocol* pProtocol;
};
//处理增加钻石的请求
class AddDimondCommnd :public AbstractCommand{
public:
AddDimondCommnd(HandleClientProtocol* protocol) {
this->pProtocol = protocol;
}
virtual void handle() {
this->pProtocol->AddDiamod();
}
public:
HandleClientProtocol* pProtocol;
};
//处理玩家装备装备的请求
class AddEquipmentCommnd :public AbstractCommand {
public:
AddEquipmentCommnd(HandleClientProtocol* protocol) {
this->pProtocol = protocol;
}
virtual void handle() {
this->pProtocol->AddEquipment();
}
public:
HandleClientProtocol* pProtocol;
};
//处理玩家升级的请求
class AddLevelCommand :public AbstractCommand {
public:
AddLevelCommand(HandleClientProtocol* protocol) {
this->pProtocol = protocol;
}
virtual void handle() {
this->pProtocol->AddLevel();
}
public:
HandleClientProtocol* pProtocol;
};
//服务器程序
class Server {
public:
void addRequest(AbstractCommand* command) {
mCommands.push(command);
}
void startHandle() {
while (!mCommands.empty()) {
Sleep(2000);
AbstractCommand* command = mCommands.front();
command->handle();
mCommands.pop();
}
}
public:
queue<AbstractCommand*> mCommands;
};
int main() {
HandleClientProtocol* protocol = new HandleClientProtocol;
//客户端增加金币的请求
AbstractCommand* addmoney = new AddMoneyCommand(protocol);
//客户端增加钻石的请求
AbstractCommand* adddimond = new AddDimondCommnd(protocol);
//客户端穿装备的请求
AbstractCommand* addequiment = new AddEquipmentCommnd(protocol);
//客户端升级的请求
AbstractCommand* addlevel = new AddLevelCommand(protocol);
//将客户端请求加入到处理的队列中
Server* server = new Server;
server->addRequest(addmoney);
server->addRequest(adddimond);
server->addRequest(addequiment);
server->addRequest(addlevel);
//服务器开始处理请求
server->startHandle();
return 0;
}
三、策略模式
定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
类别 | 描述 |
适用场景 |
|
优点 |
|
缺点 |
|
#include <iostream>
using namespace std;
//抽象武器 武器策略
class WeaponStrategy {
public:
virtual void UseWeapon() = 0;
};
class Knife : public WeaponStrategy {
public:
virtual void UseWeapon() {
cout << "使用匕首!" << endl;
}
};
class AK47 : public WeaponStrategy{
public:
virtual void UseWeapon() {
cout << "使用AK47!" << endl;
}
};
class Character {
public:
void setWeapon(WeaponStrategy* weapon) {
this->pWeapon = weapon;
}
void ThrowWeapon() {
this->pWeapon->UseWeapon();
}
private:
WeaponStrategy* pWeapon;
};
int main() {
//创建角色
Character* character = new Character;
//武器策略
WeaponStrategy* knife = new Knife;
WeaponStrategy* ak47 = new AK47;
character->setWeapon(knife);
character->ThrowWeapon();
character->setWeapon(ak47);
character->ThrowWeapon();
delete ak47;
delete knife;
delete character;
return 0;
}
四、观察者模式
观察者模式是用于建立一种对象与对象之间的依赖关系,一个对象发生改变时将自动通知其他对象,其他对象将相应作出反应。在观察者模式中,发生改变的对象称为观察目标,而被通知的对象称为观察者。
#include <iostream>
#include <list>
using namespace std;
//抽象的英雄
class AbstractHero {
public:
virtual void Update() = 0;
};
class HeroA :public AbstractHero {
public:
HeroA() {
cout << "英雄A正在撸Boss..." << endl;
}
virtual void Update() {
cout << "英雄A停止撸,待机状态..." << endl;
}
};
class HeroB :public AbstractHero {
public:
HeroB() {
cout << "英雄B正在撸Boss..." << endl;
}
virtual void Update() {
cout << "英雄B停止撸,待机状态..." << endl;
}
};
class HeroC :public AbstractHero {
public:
HeroC() {
cout << "英雄C正在撸Boss..." << endl;
}
virtual void Update() {
cout << "英雄C停止撸,待机状态..." << endl;
}
};
class HeroD :public AbstractHero {
public:
HeroD() {
cout << "英雄D正在撸Boss..." << endl;
}
virtual void Update() {
cout << "英雄D停止撸,待机状态..." << endl;
}
};
class HeroE :public AbstractHero {
public:
HeroE() {
cout << "英雄E正在撸Boss..." << endl;
}
virtual void Update() {
cout << "英雄E停止撸,待机状态..." << endl;
}
};
//观察目标抽象
class AbstractBoss {
public:
//添加观察者
virtual void addHero(AbstractHero* hero) = 0;
//删除观察者
virtual void deleteHero(AbstractHero* hero) = 0;
//通知所有观察者
virtual void notify() = 0;
};
//具体的观察者 BOSSA
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)->Update();
}
}
public:
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* bossA = new BOSSA;
bossA->addHero(heroA);
bossA->addHero(heroB);
bossA->addHero(heroC);
bossA->addHero(heroD);
bossA->addHero(heroE);
cout << "heroC阵亡..." << endl;
bossA->deleteHero(heroC);
cout << "BOSS死了...通知其他英雄停止攻击,抢装备..." << endl;;
bossA->notify();
return 0;
}