设计模式学习笔记（C++实现）（十五）--命令模式

1.命令模式简介

• 英文名称
  Command
• 主要目的
  命令模式将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持撤销的操作。
• 使用场景
  1.抽象出待执行的动作以参数化某对象；
  2.在不同的时刻指定、排列和执行请求；
  3.支持请求的取消操作；
  4.支持修改日志，这样当系统崩溃时，这些修改可以重做一次；
  5.用构建在原语操作上的高层操作构建一个系统。

2.命令模式代码示例

• 测试平台
  1.开发语言：C++
  2.开发工具：VS2015
  3.操作系统：Win7 X64

• 代码说明
  1.Receiver–抽象接收者类，定义抽象接口；
  2.DevelopReceiver、MarketReceiver–具体接收者类，用来执行具体的命令。在本例中表示研发部和销售部；
  3.Command–抽象命令类，定义抽象接口；
  4.DevelopCommand、MarketCommand–具体命令类，表示各种具体的命令。在本例中表示研发命令和销售命令；
  5.Invoker–命令发布和推动执行类，用来发布各种命令和推动命令的执行。本例中表示总经理助理。

  注意：
  1.本例用命令模式来描述总经理助理如何推动执行各种公司命令；
  2.Invoker类用于同一发布各种不同类型的命令，并推动具体的命令执行。

• 具体代码

#include <iostream>
using namespace std;

//抽象命令接收者，创建抽象接口
class Receiver
{
public:
    //函数功能：抽象执行命令接口
    //参数：    无
    //返回值：  无
    virtual void HandleAction() = 0;                 
};

//DevelopReceiver,研发命令接收者类，创建一个具体的命令执行对象
class DevelopReceiver:public Receiver
{
public:
    //函数功能：执行命令
    //参数：    无
    //返回值：  无
    void HandleAction()
    {
        cout << "研发部执行“研发”命令!" << endl;
    }
};

//MarketReceiver,销售命令接收者类，创建一个具体的命令执行对象
class MarketReceiver :public Receiver
{
public:
    //函数功能：执行命令
    //参数：    无
    //返回值：  无
    void HandleAction()
    {
        cout << "销售部执行“销售”命令!" << endl;
    }
};

//抽象命令类,定义抽象执行接口
class Command
{
public:
    //函数功能：构造函数
    //参数：    Receiver* pReceiver[IN]                -- 命令的接收者
    //返回值：  无
    Command(Receiver* pReceiver)                     
    {
        if (pReceiver != NULL)
        {
            this->m_pReceiver = pReceiver;
        }
    }

    //函数功能：抽象执行函数
    //参数：    无
    //返回值：  无
    virtual void Execute() = 0;    
protected:
    Receiver* m_pReceiver;                            //命令的具体接收者
};

//研发命令类，具体命令类，将命令绑定给一个具体的接收者，并调用接收者执行命令
class DevelopCommand :public Command
{
public:
    //函数功能：构造函数
    //参数：    Receiver* pReceiver[IN]                -- 命令的接收者
    //返回值：  无
    DevelopCommand(Receiver* pReceive) :
        Command(pReceive) {}

    virtual void Execute()
    {
        if (this->m_pReceiver != NULL)
        {
            this->m_pReceiver->HandleAction();
        }
    }
};

//市场命令类，具体命令类，将命令绑定给一个具体的接收者，并调用接收者执行命令
class MarketCommand :public Command
{
public:
    //函数功能：构造函数
    //参数：    Receiver* pReceiver[IN]                -- 命令的接收者
    //返回值：  无
    MarketCommand(Receiver* pReceive) :
        Command(pReceive) {}

    virtual void Execute()
    {
        if (this->m_pReceiver != NULL)
        {
            this->m_pReceiver->HandleAction();
        }
    }
};

//Invoke类，发布命令，并让对应的接收者执行命令
class Invoker
{
public:
    //函数功能：发布命令
    //参数：    Command* pCommand[IN]                -- 具体的命令
    //返回值：  无
    void SetCommand(Command* pCommand)
    {
        if (pCommand != NULL)
        {
            this->m_pCommand = pCommand;
        }
    }

    //函数功能：让命令的接收者执行命令
    //参数：    无
    //返回值：  无
    void ExecuteCommand()
    {
        if (this->m_pCommand != NULL)
        {
            this->m_pCommand->Execute();
        }
    }
private:
    Command* m_pCommand;                               //命令
};

int main()
{
    //命令类，本例中可以指总经理助理，负责传达具体的命令给相应的部门
    Invoker* pInvoker = new Invoker();

    //让销售部执行销售命令
    Receiver* pMarketer = new MarketReceiver();
    Command* pMarketCommand = new MarketCommand(pMarketer);
    pInvoker->SetCommand(pMarketCommand);
    pInvoker->ExecuteCommand(); 

    cout << endl;
    //让研发部执行研发命令
    Receiver* pDeveloper = new DevelopReceiver();
    Command* pDevelopCommand = new MarketCommand(pDeveloper);
    pInvoker->SetCommand(pDevelopCommand);
    pInvoker->ExecuteCommand();

    delete pMarketer;
    pMarketer = NULL;

    delete pMarketCommand;
    pMarketCommand = NULL;

    delete pDeveloper;
    pDeveloper = NULL;

    delete pDevelopCommand;
    pDevelopCommand = NULL;

    delete pInvoker;
    pInvoker = NULL;

    getchar();
    return 0;
}

• 输出结果
  

栏目导航
上一篇：设计模式学习笔记（C++实现）（十四）–职责链模式
下一篇：设计模式学习笔记（C++实现）（十六）–解释器模式

参考文献：
1.《设计模式：可复用面向对象软件的基础》