1)观察者模式,测试代码如下
//意义:,定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新;说白了,就是一个对象的改变会影响另一个对象的变化;
#include<iostream>
#include<algorithm>
#include<list>
#include<queue>
#include<windows.h>
using namespace std;
//抽象观察者
class AbstractHero
{
public:
virtual void Update() = 0;
};
//具体观察者
class HeroA : public AbstractHero
{
public:
virtual void Update()
{
cout<<"heroA stop Hit boss,standby status"<<endl; //英雄A停止打Boss,处于待机状态
}
HeroA(){ cout<< "heroA hit boss"<<endl; }//英雄A打Boss
};
class HeroB : public AbstractHero
{
public:
virtual void Update()
{
cout<<"heroB stop Hit boss,standby status"<<endl; //英雄B停止打Boss,处于待机状态
}
HeroB(){ cout<< "heroB hit boss"<<endl; }//英雄B打Boss
};
class HeroC : public AbstractHero
{
public:
virtual void Update()
{
cout<<"heroC stop Hit boss,standby status"<<endl;//英雄C停止打Boss,处于待机状态
}
HeroC(){ cout<<"heroC hit boss"<<endl; } //英雄C打Boss
};
class HeroD : public AbstractHero
{
public:
virtual void Update()
{
cout<<"heroD stop Hit boss,standby status"<<endl; //英雄D停止打Boss,处于待机状态
}
HeroD(){ cout<< "heroD hit boss---"<<endl; }//英雄D打Boss
};
//观察目标抽象
class AbstractBoss
{
public:
virtual void addAhero(AbstractHero* hero) = 0; //增加观察者
virtual void deleteAhero(AbstractHero* hero) = 0;//删除观察者
virtual void notify(void) = 0; //通知观察者
};
//具体观察者
class BossA : public AbstractBoss
{
public:
virtual void addAhero(AbstractHero* hero)
{
pHeroList.push_back(hero);
}
virtual void deleteAhero(AbstractHero* hero)
{
pHeroList.remove(hero);
}
virtual void notify(void)
{
for(auto e : pHeroList)
{
e->Update();
}
}
public:
list<AbstractHero*> pHeroList;
};
void test01()
{
//创建观察者
AbstractHero* heroA = new HeroA;
AbstractHero* heroB = new HeroB;
AbstractHero* heroC = new HeroC;
AbstractHero* heroD = new HeroD;
//创建观察目标
AbstractBoss* bossA = new BossA;
bossA->addAhero(heroA);
bossA->addAhero(heroB);
bossA->addAhero(heroC);
bossA->addAhero(heroD);
cout<<"heroC Heart Stop,Death"<<endl; //英雄C死亡
bossA->deleteAhero(heroC);
cout<<"boss heart stop,notify all hero"<<endl;
bossA->notify();
}
int main(void)
{
test01();
return 0;
}
测试输出结果:
heroA hit boss
heroB hit boss
heroC hit boss
heroD hit boss---
heroC Heart Stop,Death
boss heart stop,notify all hero
heroA stop Hit boss,standby status
heroB stop Hit boss,standby status
heroD stop Hit boss,standby status
2)命令模式代码案例如下:
命令模式(Command Pattern)意义:是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令;
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<windows.h>
using namespace std;
//命令模式
//协议处理类
class HandleClinentProtocol
{
public:
void Addmoney(){ cout<<"add money"<<endl; }
void AddDiamond(){ cout<<"add Diamond"<<endl; }
void AddEquipment(){ cout<<"add equipment"<<endl; }
void AddLevel(){ cout<<"add Level"<<endl; }
};
//命令接口
class AbstractCommond
{
public:
virtual void handle() = 0; //处理客户端请求的接口
};
//处理增加金币请求
class addMoneyCommand : public AbstractCommond
{
public:
addMoneyCommand(HandleClinentProtocol* protocol)
{
this->pProtocol = protocol;
}
virtual void handle()
{
this->pProtocol->Addmoney();
}
public:
HandleClinentProtocol* pProtocol;
};
class addDiamondCommand : public AbstractCommond //增加玩家钻石请求
{
public:
addDiamondCommand(HandleClinentProtocol* protocol)
{
this->pProtocol = protocol;
}
virtual void handle()
{
this->pProtocol->AddDiamond();
}
public:
HandleClinentProtocol* pProtocol;
};
class addEquipmentCommand : public AbstractCommond //处理玩家装备请求
{
public:
addEquipmentCommand(HandleClinentProtocol* protocol)
{
this->pProtocol = protocol;
}
virtual void handle()
{
this->pProtocol->AddEquipment();
}
public:
HandleClinentProtocol* pProtocol;
};
class addLevelCommand : public AbstractCommond //处理玩家升级请求
{
public:
addLevelCommand(HandleClinentProtocol* protocol)
{
this->pProtocol = protocol;
}
virtual void handle()
{
this->pProtocol->AddLevel();
}
public:
HandleClinentProtocol* pProtocol;
};
//服务器程序
class Service
{
public:
void addRequest(AbstractCommond* command)
{
mCommands.push(command);
}
void startHandle()
{
while(!mCommands.empty())
{
Sleep(2000);
AbstractCommond* command = mCommands.front();
command->handle();
mCommands.pop();
}
}
public:
queue<AbstractCommond*> mCommands;
};
void test01()
{
HandleClinentProtocol* protocol = new HandleClinentProtocol;
AbstractCommond* addmoney = new addMoneyCommand(protocol); //客户端增加金币请求
AbstractCommond* addDiamond = new addDiamondCommand(protocol); //客户端增加钻石请求
AbstractCommond* addEquipment = new addEquipmentCommand(protocol); //客户端增加装备请求
AbstractCommond* addLevel = new addLevelCommand(protocol); //客户端增加升级请求
Service* server = new Service; //模拟将客户端请求加入到服务器
server->addRequest(addmoney);
server->addRequest(addDiamond);
server->addRequest(addEquipment);
server->addRequest(addLevel);
//服务器处理请求
server->startHandle();
}
int main(void)
{
test01();
cout<<"running over"<<endl;
return 0;
}
测试输出结果(间隔两秒钟打印一次客户端请求(应用队列方法)):
add money
add Diamond
add equipment
add Level
running over
3)适配器模式,很好理解,就是已经有板子了,根据自己需要设计一个套筒,o( ̄︶ ̄)o
测试代码如下:
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct MyPoint
{
void operator()(int v1, int v2)
{
cout<<v1 + v2<<" ";
}
};
//定义目标接口
class Target
{
public:
virtual void operator()(int v) = 0;
};
//写适配器
class Adapter : public Target
{
public:
virtual void operator()(int v)
{
PointPrint(v,100); //固定一个数作为绑定数值
}
public:
MyPoint PointPrint;
};
int main(void)
{
vector<int> v;
for(int i = 0; i < 10; i++)
{
v.push_back(i);
}
for_each(v.begin(),v.end(),Adapter());
return 0;
}
//动态绑定参数方法
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct MyPoint
{
void operator()(int v1, int v2)
{
cout<<v1 + v2<<" ";
}
};
//定义目标接口
class Target
{
public:
virtual void operator()(int v) = 0;
};
//写适配器
class Adapter : public Target
{
public:
Adapter(int v){ bindNum = v; }
virtual void operator()(int v)
{
PointPrint(v,bindNum);
}
public:
MyPoint PointPrint;
int bindNum;
};
//自定义一个绑定函数 MYBind2nd
Adapter MyBind2nd(int v)
{
return Adapter(v);
}
int main(void)
{
vector<int> v;
for(int i = 0; i < 10; i++)
{
v.push_back(i);
}
for_each(v.begin(),v.end(),MyBind2nd(10)); //在原基础数值上都加上10
return 0;
}
上面代码中,有两个案例,一个是静态绑定(直接写个数),另一个是动态绑定(用户自己写的绑定值),下面测试结果是按动态绑定测试,结果如下:
10 11 12 13 14 15 16 17 18 19
- 装饰器模式
测试代码如下:
装饰器模式(Decorator Pattern):允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装;
#include<iostream>
#include<algorithm>
#include<list>
#include<queue>
#include<windows.h>
using namespace std;
//装饰模式
//装饰模式也叫包装模式,可以动态的给一个类增加功能
class AbstractHero
{
public:
virtual void showStatus() = 0;
virtual ~AbstractHero(){ }
public:
int mHp;
int mMp;
int mAt;
int mDf;
};
//裸奔英雄
class HeroA : public AbstractHero
{
public:
HeroA()
{
mHp = 0;
mMp = 0;
mAt = 0;
mDf = 0;
}
virtual void showStatus()
{
cout<<"blood: "<<mHp<<endl; //血量
cout<<"hit: "<<mMp<<endl; //攻击
cout<<"magic: "<<mAt<<endl; //魔法
cout<<"weapon: "<<mDf<<endl;//武器
}
};
//英雄穿上某个装饰物,那他还是个英雄
class AbstractEquipment : public AbstractHero
{
public:
AbstractEquipment(AbstractHero* hero)//把没穿衣服的英雄扔进来,生成有装备的英雄
{
this->pHero = hero;
}
virtual void showStatus() { }
public:
AbstractHero* pHero;
};
//狂徒衣服
class KuangTuEquipment : public AbstractEquipment
{
public:
KuangTuEquipment(AbstractHero* hero) : AbstractEquipment(hero) { }
//增加额外功能
void addKuangTu()
{
cout<<"hero adding equipment"<<endl;
this->mHp = this->pHero->mHp;
this->mMp = this->pHero->mMp + 30;
this->mAt = this->pHero->mAt;
this->mDf = this->pHero->mDf;
delete this->pHero;
}
virtual void showStatus()
{
addKuangTu();
cout<<"blood: "<<mHp<<endl; //血量
cout<<"hit: "<<mMp<<endl; //攻击
cout<<"magic: "<<mAt<<endl; //魔法
cout<<"weapon: "<<mDf<<endl;//武器
}
};
//武器加上刀
class KnifeEquipment : public AbstractEquipment
{
public:
KnifeEquipment(AbstractHero* hero) : AbstractEquipment(hero) { }
//增加额外功能
void addKnife()
{
cout<<"hero add weapon knife"<<endl;
this->mAt = this->pHero->mAt;
this->mDf = this->pHero->mDf;
this->mHp = this->pHero->mHp + 40;
this->mMp = this->pHero->mMp;
delete this->pHero;
}
virtual void showStatus()
{
addKnife();
cout<<"blood: "<<mHp<<endl; //血量
cout<<"hit: "<<mMp<<endl; //攻击
cout<<"magic: "<<mAt<<endl; //魔法
cout<<"weapon: "<<mDf<<endl;//武器
}
};
void test01()
{
AbstractHero* hero = new HeroA;
hero->showStatus();
cout<<"---------------------"<<endl;
//给裸奔的英雄穿上衣服
hero = new KuangTuEquipment(hero);
hero->showStatus();
//给英雄装备武器
hero = new KnifeEquipment(hero);
hero->showStatus();
}
int main(void)
{
test01();
return 0;
}
测试结果如下:
blood: 0
hit: 0
magic: 0
weapon: 0
---------------------
hero adding equipment
blood: 0
hit: 30 //在原基础上增加30
magic: 0
weapon: 0
hero add weapon knife
blood: 40
hit: 30
magic: 0
weapon: 0