C++设计模式学习二

1）观察者模式，测试代码如下
//意义:，定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新；说白了，就是一个对象的改变会影响另一个对象的变化；

#include
#include
#include
#include
#include

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
#include
#include
#include
#include

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
#include
#include

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
#include
#include

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

4. 装饰器模式
   测试代码如下：
   装饰器模式（Decorator Pattern）：允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装；

#include
#include
#include
#include
#include

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