C++命令模式

最新推荐文章于 2022-04-10 01:08:09 发布
最新推荐文章于 2022-04-10 01:08:09 发布
阅读量278 收藏 5
点赞数 2
文章标签： c/c++ 设计模式 ui
原文链接：https://yq.aliyun.com/articles/119786
版权

简述

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

版权所有：一去丶二三里，转载请注明出处：http://blog.csdn.net/liang19890820

背景

在应用程序中，经常需要对相同的数据执行多个操作。可以这样简单的理解：用户有一些数据，并且界面提供了很多选项，他可以对该数据进行其中的某些操作。例如，图片处理器：可以选择旋转/翻转/反转照片。另外，一旦有不满意的处理，很有可能需要撤消。这就是基本的业务逻辑，必须要在实现过程中考虑清楚。

大多情况下，最容易想到的是：当动作触发后，调用接收者对应的方法。但是这存在不少问题：

  • 要写很多条件代码，必须为每个操作编写非常类似的代码。
  • 如果有更多的命令，就会发现需要经常更改现有代码。

显然，这种无法抵御变化的紧耦合设计不太合适。在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，实现二者之间的松耦合。这就是命令模式。

模式结构

UML 结构图：

Command Pattern

  • Command：定义命令的接口，声明执行的方法。
  • ConcreteCommand：命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
  • Receiver：接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
  • Invoker：要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
  • Client：创建具体命令对象，并设置其接收者（注意： 这并非常规意义上的客户端，而是在组装命令对象和接收者。或许，把这个 Client 称为装配者会更好理解，因为真正使用命令的客户端是从 Invoker 来触发执行）。

代码实现

简易计算器

简易计算器主要专注于理解命令模式，而不是实现一个真正的计算器。因此，将对一组固定的数据（x = 20, y = 10）进行基本操作（加减乘除）。假设将创建一个这样的应用程序：

这里写图片描述

从 Command 类开始，这是一个抽象类，将被用作执行命令的接口。其他的 ConcreteCommand 类派生自它，提供了具体的命令（加减乘除）。

command.h

#ifndef COMMAND_H
#define COMMAND_H

class IReciever;

// 提供执行命令的接口
class Command
{
public:
    Command(IReciever *reciever);
    virtual int execute() = 0;  // 执行命令
protected:
    IReciever *m_pReciever;
};

// 加法
class AddCommand : public Command
{
public:
    AddCommand(IReciever *reciever);
    int execute();
};

// 减法
class SubtractCommand : public Command
{
public:
    SubtractCommand(IReciever *reciever);
    int execute();
};

// 乘法
class MultiplyCommand : public Command
{
public:
    MultiplyCommand(IReciever *reciever);
    int execute();
};

// 除法
class DivideCommand : public Command
{
public:
    DivideCommand(IReciever *reciever);
    int execute();
};

#endif // COMMAND_H

command.cpp

#include "command.h"
#include "reciever.h"

Command::Command(IReciever *reciever)
    : m_pReciever(reciever)
{

}

// 加法
AddCommand::AddCommand(IReciever *reciever)
    : Command(reciever)
{

}

int AddCommand::execute()
{
    m_pReciever->setAction(TYPES::ACTION::ADD);
    return m_pReciever->getResult();
}

// 减法
SubtractCommand::SubtractCommand(IReciever *reciever)
    : Command(reciever)
{

}

int SubtractCommand::execute()
{
    m_pReciever->setAction(TYPES::ACTION::SUBTRACT);
    return m_pReciever->getResult();
}

// 乘法
MultiplyCommand::MultiplyCommand(IReciever *reciever)
    : Command(reciever)
{

}

int MultiplyCommand::execute()
{
    m_pReciever->setAction(TYPES::ACTION::MULTIPLY);
    return m_pReciever->getResult();
}

// 除法
DivideCommand::DivideCommand(IReciever *reciever)
    : Command(reciever)
{

}

int DivideCommand::execute()
{
    m_pReciever->setAction(TYPES::ACTION::DIVIDE);
    return m_pReciever->getResult();
}

准备好命令的层次结构后，现在来编写真正的程序逻辑 - 需要一个类来进行计算 - Reciever，提供了一个接口表示接收者的主要功能，其中 Calculator 类为 Reciever 的具体实现：

reciever.h

#ifndef RECIEVER_H
#define RECIEVER_H

namespace TYPES
{
    enum ACTION
    {
        ADD,  // 加法
        SUBTRACT,  // 减法
        MULTIPLY,  // 乘法
        DIVIDE   // 除法
    };
}

// 命令接收者
class IReciever
{
public:
    virtual void setAction(TYPES::ACTION action) = 0;  // 设置具体命令
    virtual int getResult() = 0;  // 获取命令结果
};

// 命令接收者具体实现
class Calculator : public IReciever
{
public:
    Calculator(int x, int y);
    void setAction(TYPES::ACTION action);
    int getResult();

private:
    int m_nX;
    int m_nY;
    TYPES::ACTION m_currentAction;
};

#endif // RECIEVER_H

reciever.cpp

#include "reciever.h"

Calculator::Calculator(int x, int y)
    : m_nX(x),
      m_nY(y)
{

}

void Calculator::setAction(TYPES::ACTION action)
{
    m_currentAction = action;
}

int Calculator::getResult()
{
    int nResult;
    switch (m_currentAction) {
    case TYPES::ACTION::ADD :
        nResult = m_nX + m_nY;
        break;
    case TYPES::ACTION::SUBTRACT :
        nResult = m_nX - m_nY;
        break;
    case TYPES::ACTION::MULTIPLY :
        nResult = m_nX * m_nY;
        break;
    case TYPES::ACTION::DIVIDE :
        nResult = m_nX / m_nY;
        break;
    default:
        break;
    }

    return nResult;
}

需要一个类，让用户选择要执行的命令 - Client（也就是 UI）。最后，还需要写一个 Invoker，在示例中依然是用户界面。

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "reciever.h"
#include "command.h"

class QLineEdit;

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = 0);
    ~Widget();

private Q_SLOTS:
    void onButtonClicked(int id);  // 设置当前命令
    void onCalculate();  // 计算结果

private:
    QLineEdit *m_pResultEdit;

    Calculator calculator;
    Command *command;  // 用于调用命令
    AddCommand addCmd;  // 加法
    SubtractCommand subCmd;  // 减法
    MultiplyCommand mulCmd;  // 乘法
    DivideCommand divCmd;  // 除法
};

#endif // WIDGET_H

widget.cpp

#include "widget.h"
#include <QButtonGroup>
#include <QRadioButton>
#include <QPushButton>
#include <QLabel>
#include <QLineEdit>
#include <QHBoxLayout>

Widget::Widget(QWidget *parent)
    : QWidget(parent),
      calculator(20, 10),
      command(nullptr),
      addCmd(&calculator),
      subCmd(&calculator),
      mulCmd(&calculator),
      divCmd(&calculator)
{
    setWindowTitle("Calculator");
    setWindowIcon(QIcon(":/logo.png"));

    // 按钮组
    QButtonGroup *pButtonGroup = new QButtonGroup(this);
    QRadioButton *pAddButton = new QRadioButton("+", this);
    QRadioButton *pSubButton = new QRadioButton("-", this);
    QRadioButton *pMulButton = new QRadioButton("*", this);
    QRadioButton *pDivButton = new QRadioButton("/", this);
    QLabel *pLabel = new QLabel("x = 20, y = 10", this);
    m_pResultEdit = new QLineEdit(this);
    QPushButton *pCalButton = new QPushButton("Calculate", this);

    m_pResultEdit->setReadOnly(true);

    pButtonGroup->addButton(pAddButton, 0);
    pButtonGroup->addButton(pSubButton, 1);
    pButtonGroup->addButton(pMulButton, 2);
    pButtonGroup->addButton(pDivButton, 3);
    pButtonGroup->setExclusive(true);  // 互斥

    QHBoxLayout *pHLayout = new QHBoxLayout();
    pHLayout->addWidget(pAddButton);
    pHLayout->addWidget(pSubButton);
    pHLayout->addWidget(pMulButton);
    pHLayout->addWidget(pDivButton);
    pHLayout->setContentsMargins(0, 0, 0, 0);
    pHLayout->setSpacing(10);

    QVBoxLayout *pLayout = new QVBoxLayout(this);
    pLayout->addWidget(pLabel);
    pLayout->addWidget(m_pResultEdit);
    pLayout->addLayout(pHLayout);
    pLayout->addWidget(pCalButton);
    pLayout->setSpacing(10);
    pLayout->setContentsMargins(10, 10, 10, 10);

    // 连接信号槽
    connect(pButtonGroup, static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &Widget::onButtonClicked);
    connect(pCalButton, &QPushButton::clicked, this, &Widget::onCalculate);

    // 默认选择加法
    pButtonGroup->button(0)->click();
}

Widget::~Widget()
{

}

// 设置当前命令
void Widget::onButtonClicked(int id)
{
    if (id == 0) {
        command = &addCmd;
    } else if (id == 1) {
        command = &subCmd;
    } else if (id == 2) {
        command = &mulCmd;
    } else if (id == 3) {
        command = &divCmd;
    }
}

// 计算结果
void Widget::onCalculate()
{
    int nResult = command->execute();
    m_pResultEdit->setText(QString::number(nResult));
}

单选按钮所触发的事件只是改变要使用的命令对象，并且当用户选择计算时，将使用适当的命令对象来获取结果。

命令队列

根据命令模式，实现一个命令队列，形成一个命令链。

以打车为例，又是滴滴（~O(∩_∩)O~），用户发起一个“打车”命令，司机接单，到达终点时，用户再次发起一个“付款”命令，司机收款。

和上述示例类似， Command 是一个抽象类，将被用作执行命令的接口。其他的 ConcreteCommand 类派生自它，提供了具体的命令（打车/付款）。

command.h

#ifndef COMMAND_H
#define COMMAND_H

class Reciever;

// 提供执行命令的接口
class Command
{
public:
    Command(Reciever *reciever);
    virtual void execute() = 0;  // 执行命令
protected:
    Reciever *m_pReciever;
};

// 打车
class TakeCommand : public Command
{
public:
    TakeCommand(Reciever *reciever);
    void execute();
};

// 付款
class PayCommand : public Command
{
public:
    PayCommand(Reciever *reciever);
    void execute();
};

#endif // COMMAND_H

command.cpp

#include "command.h"
#include "reciever.h"
#include <iostream>

Command::Command(Reciever *reciever)
    : m_pReciever(reciever)
{

}

// 打车
TakeCommand::TakeCommand(Reciever *reciever)
    : Command(reciever)
{

}

void TakeCommand::execute()
{
    std::cout << "Take command..." << std::endl;
    m_pReciever->takeOrder();
}

// 付款
PayCommand::PayCommand(Reciever *reciever)
    : Command(reciever)
{

}

void PayCommand::execute()
{
    std::cout << "Pay command..." << std::endl;
    m_pReciever->receipt();
}

有了 Command，就需要有对应的 Invoker 来持有命令，然后进行触发。

invoker.h

#ifndef INVOKER_H
#define INVOKER_H

#include <list>
#include "command.h"

// 命令的持有者
class Invoker
{
public:
    Invoker();
    void addCmd(Command *cmd);  // 添加命令
    void deleteCmd(Command *cmd);  // 删除命令
    void notify();  // 执行命令

private:
    std::list<Command *> m_cmds;  // 命令队列
};

#endif // INVOKER_H

invoker.cpp

#include "invoker.h"

Invoker::Invoker()
{

}

void Invoker::addCmd(Command *cmd)
{
    m_cmds.push_back(cmd);
}

void Invoker::deleteCmd(Command *cmd)
{
    m_cmds.remove(cmd);
}

void Invoker::notify()
{
    std::list<Command *>::iterator it = m_cmds.begin();
    while (it != m_cmds.end()) {
        (*it)->execute();
        ++it;
    }
}

最后是 Reciever，也就是司机，用于执行命令（接单/收款）。

reciever.h

#ifndef RECIEVER_H
#define RECIEVER_H

// 司机
class Reciever
{
public:
    void takeOrder();  // 接单
    void receipt();  // 收款
};

#endif // RECIEVER_H

reciever.cpp

#include "reciever.h"
#include <iostream>

// 接单
void Reciever::takeOrder()
{
    std::cout << "Take order..." << std::endl;
}

// 收款
void Reciever::receipt()
{
    std::cout << "Receipt..." << std::endl;
}

使用起来比较简单：

#include "invoker.h"
#include "reciever.h"
#include "command.h"

int main()
{
    Reciever *rev = new Reciever();
    Command *cmd1 = new TakeCommand(rev);
    PayCommand *cmd2 = new PayCommand(rev);
    Invoker inv;

    inv.addCmd(cmd1);
    inv.addCmd(cmd2);
    inv.notify();

    delete cmd1;
    delete cmd2;
    delete rev;

    return 0;
}

输出如下：

Take command…
Take order…
Pay command…
Receipt…

开始，我们创建了两个命令（打车 & 付款），通过 Invoker 的 addCmd() 将他们加入至命令队列，然后 notify() 通知执行命令，这样，就形成了一个命令链。

兴趣点

要降低发送者和接收者之间的耦合度，命令模式是一种非常好的方式。在实现命令模式时，要记住，最重要的事情是：命令只是发送者和接收者之间的链接。它应该只告诉接收者发送者期望的是什么，而不应该以任何方式改变发送者和接收者的逻辑。

weixin_33737134
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
命令模式(C++实现)
03-11
命令行模式的C++实现 编译环境VS2010 命令模式解析：http://blog.csdn.net/zs634134578/article/details/21031509
C++设计模式——命令模式
huangyimo的专栏
10-28 455
前言 又要过年了，又是一个抢票季；从大学起，到现在工作，一直都是在外地，离家千里；以前买票，曾经也去火车站通宵排队买票；直到12306的腾空出现，在电脑前不停止的点着鼠标刷票，那个时候12306很是脆弱，抢一张票更是难上加难；现在好了，慢慢强大的12306，买票时出现了一个排队系统，先买票，进入12306的排队系统；然后，系统一个一个的处理大家的请求，一旦你的购票请求进入了排队系统，你就无法
C++ 命令模式
u013571243的专栏
10-27 697
自已的逻辑图     1.所谓命令模式就是将对象A所具有的Action分别抽象成command,即命令的对象化   例如: 对象灯泡有两个动作 turnOn turnOff   2.为了让这两个action可以执行,也就是从灯泡分离开,我们创建一个抽象的类command   #ifndef COMMAND_H_ #define COMMAND_H_ cl
c++命令模式
qq_32619439的博客
04-10 1805
命令模式   作用及特点：”行为请求者“与”行为实现者“通常呈现一种”紧耦合“。但在某些场合——比如需要对行为进行”记录、撤销、事务“等处理，这种无法抵御变化的紧耦合是不合适的。 Command模式的根本目的在于将”行为请求者“与”行为实现者“解耦，在面向对象语言中，常见的实现手段是”将行为抽象为对象“。   因为命令需要有接收者，命令类和接收者类是关联关系，所以具体命令类在创建的时候，记录一下接收者的指针。命令类是有统一的执行接口，它为纯虚函数，具体的命令类可以对执行接口进行重写。命令类和管理员类为聚合关
C++设计模式之命令模式
12-26
前言 又要过年了，又是一个抢票季；从大学起，到现在工作，一直都是在外地，离家千里；以前买票，曾经也去火车站通宵排队买票；直到12306的腾空出现，在电脑前不停止的点着鼠标刷票，那个时候12306很是脆弱，抢一张...
c++命令模式实现12306购票系统
10-24
c++命令模式实现12306购票系统 详见博客：http://blog.csdn.net/caoshangpa/article/details/52912355
设计模式C++学习之命令模式（Command）
09-07
设计模式C++学习之命令模式（Command）
详解设计模式中的Command命令模式及相关C++实现
09-02
主要介绍了详解设计模式中的Command命令模式及相关C++实现,命令模式强调调用操作的对象和操作的具体实现者之间的解耦,需要的朋友可以参考下
命令模式（C++)
先锋小牛
09-23 937
简述     命令模式能比较容易的设计一个命令队列，在需要的情况下可以将命令计入日志，接收请求的一方可以否决请求。而且加进新的具体命令类不影响其他的类，因此可以比较容易的增加新的具体的命令类。 场景说明     相信大家都去过饭店吧。去了之后，首先叫服务员过来点菜，有炒饭，烧茄子，烤鱼等等（我最喜欢吃的），服务员会记录下菜名，然后交到厨房，厨师做饭。应该没有人会直接跑到后厨让厨师做饭吧，
命令模式 C++ 实现
05-04
命令模式的C++实现
命令模式实现
宝安小雨
07-12 144
学了C++基本的语法都知道继承可以让子类拥有更多的功能，除了继承还有组合，委托，也能让一个类的功能增加。设计模式，这个设计是设计继承，组合，委托，之间相互叠加的方式，让其符合业务需求。 命令模式是委托和继承的运用实例，它把一个类的函数转换成一个对象。通过多个类把一个类A作为它的委托，在各自类中调用这个类A的不同函数来实现。这样做看似有些多次一举，但如果碰到这样的需求，那这是很好的专家级的解决方案。如果我们的要调用的函数以千计，此设计模式可把这些函数转换为一个个对象，然后把这些对象放进容器里...
[C++]命令模式
就是那个党伟
10-17 146
命令模式，将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志；以及支持可撤销的操作。 // 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // // 参考大话设计模式 #include <iostream> using namespace std; class Receiver { public: void Action() { cout << "receive do action." <<
C++ 之 命令模式
wjjontheway的专栏
01-08 1146
文章目录结构描述说明CommandConcreteCommandClientInvokerReceiver协作方式Demo 结构 描述 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作 说明 Command 声明执行操作的接口，通常命名为ICommand，具体的Command会以继承该接口并重写其execut接口 ConcreteCommand 将一个接收者对象绑定于一个动作，之后，调用接收者相应的操作，以实现Execute来完成相应的命令
我所理解的设计模式（C++实现）——命令模式（Command Pattern）
runfeel
06-12 572
概述： 我们去餐厅吃饭，我们是通过服务员来点菜，具体是谁来做这些菜和他们什么时候完成的这些菜，其实我们都不知道。抽象之，“菜单请求者”我们和“菜单实现者”厨师，2者之间是松耦合的，我们对这些菜的其他一些请求比如“撤销，重做”等，我们也不知道是谁在做。其实这就是本文要说的Command模式。 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请...
C++实现命令模式
u013216156的专栏
07-21 411
概述： 命令模式是一种行为型模式，将一个请求封装成一个对象，从而可以用不同的请求对象进行参数化 优点： 降低命令请求端和接收端的耦合度 新的命令只需要封装成相应的对象，就可以添加到系统中，可扩展性好 缺点： 命令比较多的情况下，会导致创建过多的命令类 使用场景： 客户端有多个请求协议的情况下，可以将协议当做命令 UML类图： 实例： #include <iostrea...
命令模式(C++)
Mr Lin 的专栏
03-02 158
命令模式将发送者与接收者解耦，如开关1 --- 电灯，开关2---电脑，开关3---其他电器，它将一个请求封装成一个对象，可以让你用不同的请求对客户进行参数化。 命令模式包含四种角色： 1.Command(抽象命令类) 2.ConcreteCommand(具体命令类) 3.Invoker(调用者) 4.Receiver(接收者) C++代码如下 #include &lt;...
c++ 命令模式 如果理解
最新发布
04-07
C命令模式是一种设计模式，它将请求封装成对象，从而允许使用不同的请求、队列或日志来参数化其他对象。这种模式中，命令模式可以将发出请求的对象和执行请求的对象解耦。如果您有任何其他问题，请随时问我哦~ 说到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值