019 --- 第23章 命令模式

简述：

　　命令模式：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数话；对请求队列化或记录请求日志，以及支持可撤销的操作。

　　命令模式包括：命令者类、命令类、接收者类、具体命令类。

　　　　命令者类：要求该命令执行这个请求，封装了命令类的队列。

　　　　命令类：抽象命令，用来声明执行操作的接口。

　　　　接收者类：知道如何实施与执行一个请求相关的操作，任何类都可能作为一个接收者。

　　　　具体命令类：将一个接收者对象绑定一个动作，调用接收者响应的操作，以实现执行具体命令。

命令模式：

// 接收者类
class CReceiver
{
public:
    void Action()
    {
        cout << "执行请求！" << endl;
    }
};

// 命令类
class CCommand
{
protected:
    CReceiver* m_pReceiver;

public:
    CCommand(CReceiver* pReceiver)
    {
        m_pReceiver = pReceiver;
    }

    virtual void Execute() = 0;
};

// 具体命令类
class CConcreteCommand : public CCommand
{
public:
    CConcreteCommand(CReceiver* pReceiver) : CCommand(pReceiver) {}

    virtual void Execute()
    {
        m_pReceiver->Action();
    }
};

// 命令者类
class CInvoker
{
private:
    CCommand* m_pCommand;
    
public:
    void SetCommand(CCommand* pCommand)
    {
        m_pCommand = pCommand;
    }

    void ExecuteCommand()
    {
        m_pCommand->Execute();
    }
};

int main()
{
    CReceiver Receiver;
    CConcreteCommand Command(&Receiver);
    CInvoker Invoker;
    Invoker.SetCommand(&Command);
    Invoker.ExecuteCommand();

    system("pause");
    return 0;
}

输出结果：

例：串店点串

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <list>
#include <time.h>
#include <Windows.h>
using namespace std;

// 烤肉串者类（接收者类）
class CBarbecuer
{
public:
    void BakeMutton()
    {
        cout << "烤羊肉串" << endl;
    }

    void BakeChickenWing()
    {
        cout << "烤鸡翅" << endl;
    }
};

// 命令类
class CCommand
{
protected:
    CBarbecuer* m_pBarbecuer;

public:
    CCommand(CBarbecuer* pBarbecuer)
    {
        m_pBarbecuer = pBarbecuer;
    }

    // 执行命令
    virtual void ExecuteCommand() = 0;
};

// 烤羊肉串命令类(具体命令类)
class CBakeMuttonCommand : public CCommand
{
public:
    CBakeMuttonCommand(CBarbecuer* pBarbecuer) : CCommand(pBarbecuer) {}

    virtual void ExecuteCommand()
    {
        m_pBarbecuer->BakeMutton();
    }
};

// 烤鸡翅命令类(具体命令类)
class CBakeChickenWingCommand : public CCommand
{
public:
    CBakeChickenWingCommand(CBarbecuer* pBarbecuer) : CCommand(pBarbecuer) {}

    virtual void ExecuteCommand()
    {
        m_pBarbecuer->BakeChickenWing();
    }
};

// 服务员类（命令者类）
class CWaiter
{
private:
    //CCommand* m_pCommand;
    list<CCommand*> m_lstCommand;

public:
    // 设置订单
    void SetOrder(CCommand* pCommand)
    {
        //m_pCommand = pCommand;
        if (typeid(*pCommand) == typeid(CBakeChickenWingCommand))
        {
            cout << "服务员：鸡翅没有了，请点别的烧烤。" << endl;
        }
        
        if(typeid(*pCommand) == typeid(CBakeMuttonCommand))
        {
            m_lstCommand.push_back(pCommand);
            time_t now = time(0);
            cout << "增加订单：烤羊肉串 -> 时间：" << asctime(localtime(&now));
        }
    }

    // 取消订单
    void CancelOrder(CCommand* pCommand)
    {
        if (typeid(*pCommand) == typeid(CBakeChickenWingCommand))
        {
            m_lstCommand.remove(pCommand);
            time_t now = time(0);
            cout << "取消订单：烤鸡翅 -> 时间：" << asctime(localtime(&now));
        }

        if (typeid(*pCommand) == typeid(CBakeMuttonCommand))
        {
            m_lstCommand.remove(pCommand);
            time_t now = time(0);
            cout << "取消订单：烤羊肉串 -> 时间：" << asctime(localtime(&now));
        }
        
    }

    // 通知执行
    void Notify()
    {
        //m_pCommand->ExecuteCommand();
        for (auto pCommand : m_lstCommand)
            pCommand->ExecuteCommand();
    }
};

int main()
{
    // 开店前准备
    CBarbecuer Barbecuer;
    CBakeMuttonCommand BakeMuttonConmmand1(&Barbecuer);
    CBakeMuttonCommand BakeMuttonConmmand2(&Barbecuer);
    CBakeChickenWingCommand BakChickenWingConmmand1(&Barbecuer);
    CWaiter Waiter;

    // 开门营业，顾客点菜
    Waiter.SetOrder(&BakeMuttonConmmand1);
    Waiter.SetOrder(&BakeMuttonConmmand2);
    Waiter.SetOrder(&BakChickenWingConmmand1);
    Sleep(2000);
    Waiter.CancelOrder(&BakChickenWingConmmand1);
    // 点菜完毕，通知厨房
    Waiter.Notify();

    system("pause");
    return 0;
}

输出结果：