设计模式--行为型模式

行为型模式

行为型模式	类型
关注对象之间的通信	命令模式（Command Pattern） 责任链模式（Chain of Responsibility Pattern ) 解释器模式（Interpreter Pattern） 迭代器模式（Iterator Pattern） 中介者模式（Mediator Pattern） 备忘录模式（Memento Pattern） 观察者模式（Observer Pattern） 状态模式（State Pattern） 空对象模式（Null Object Pattern） 策略模式（Strategy Pattern） 模板模式（Template Pattern） 访问者模式（Visitor Pattern）

命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。 在OOP中，一切都是对象，将请求封装成对象，符合OOP的设计思想，当将客户的单个请求封装成对象以后，我们就可以对这个请求存储更多的信息，使请求拥有更多的能力；命令模式同样能够把请求发送者和接收者解耦，使得命令发送者不用去关心请求将以何种方式被处理。

参与者

• Command：声明执行操作的接口；
• ConcreteCommand：将一个接收者对象绑定于一个动作，之后，调用接收者相应的操作，以实现Execute来完成相应的命令；
• Client：创建一个具体命令对象，但是并没有设定它的接收者； Invoker：要求该命令执行这个请求；
• Receiver：知道如何实施与执行一个请求相关的操作，任何类都可能作为一个接收者。

协作

1. Client创建一个ConcreteCommand命令对象，并指定它的Receiver对象
2. Invoker对象存储该ConcreteCommand对象；
3. 该Invoker通过调用Command对象的Execute操作来提交一个请求。如果这个命令请求是可以撤销的，ConcreteCommand就执行Execute操作之前存储当前状态以用于取消该命令请求；
4. ConcreteCommand对象调用Receiver的一些操作以执行该请求。

优点：

1. 降低了系统耦合度。
2. 新的命令可以很容易添加到系统中去。

缺点：

1. 使用命令模式可能会导致某些系统有过多的具体命令类。

具体事例：
我们去餐厅吃饭，我们是通过服务员来点菜，具体是谁来做这些菜和他们什么时候完成的这些菜，其实我们都不知道。抽象之，我们是“菜单请求者”，厨师是“菜单实现者”，2者之间是松耦合的，我们对这些菜的其他一些请求比如“撤销，重做”等，我们也不知道是谁在做。其实这就是本文要说的Command模式。将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。[GOF 《设计模式》]

#include <iostream>  
#include <string>
#include <vector>
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

/*烤肉师傅类，只负责烤串工作*/
class Barbecuer
{
public:
    void BakeMutton(){cout<<"Bake mutton"<<endl;}
    void BakeChickenWing(){cout<<"Bake ChickenWing"<<endl;}
};

/*抽象命令类：是执行具体操作的接口*/
class Command
{
public:
    Command(){}
    Command(Barbecuer *receiver):p_receiver(receiver){}
    virtual void ExecuteCommand() = 0; //执行命令
protected:
    Barbecuer *p_receiver;
};

/*具体命令类:烤羊肉串命令*/
class BakeMuttonCommand:public Command
{
public:
    BakeMuttonCommand(Barbecuer *receiver){p_receiver = receiver;}
    void ExecuteCommand(){p_receiver->BakeMutton();}
};

/*具体命令类:烤鸡翅串命令*/
class BakeChickenWingCommand:public Command
{
public:
    BakeChickenWingCommand(Barbecuer *receiver){p_receiver = receiver;}
    void ExecuteCommand()
    {p_receiver->BakeChickenWing();}
};

/*服务员类*/
class Waiter
{
public:
    void SetOrder(Command *command);
    void Notify();
private:
    vector<Command *>p_commandList; //这里相当于一个命令对象队列
};

void Waiter::SetOrder(Command *command)
{
    p_commandList.push_back(command);
    cout << "增加烤肉命令" << endl;
}

void Waiter::Notify()
{
    vector<Command*>::iterator i;
    for(i = p_commandList.begin(); i != p_commandList.end(); ++ i)
        (*i)->ExecuteCommand();
}

int main(int argc, char *argv[])  
{  
    //生成烤肉师傅、服务员、订单对象
    Barbecuer *p_cook = new Barbecuer();
    Command *p_mutton = new BakeMuttonCommand(p_cook);
    Command *p_chickenwing = new BakeChickenWingCommand(p_cook);
    Waiter *p_waiter = new Waiter();

    //将订单对象推送到命令队列
    p_waiter->SetOrder(p_mutton);
    p_waiter->SetOrder(p_chickenwing);

    //服务员通知烤肉师傅具体订单
    p_waiter->Notify();

    SAFE_DELETE(p_cook);
    SAFE_DELETE(p_mutton);
    SAFE_DELETE(p_chickenwing);
    SAFE_DELETE(p_waiter);

    return 0;  
}

参考：
https://www.cnblogs.com/lizhanwu/p/4435359.html
https://www.runoob.com/design-pattern/command-pattern.html