《设计模式》命令模式

Posted 2023-03-05 joker D888

《设计模式》命令模式

命令模式（Command Pattern）是一种行为型设计模式，它将请求和处理分开，使得请求发送者和接收者解耦，从而降低系统的耦合度。在命令模式中，请求被封装为一个独立的对象，并且将其参数化，以便在不同的请求中传递不同的参数。命令模式中的对象包括：

1. 请求者（Invoker）：负责向命令对象发起请求，并将命令对象设置为接收者的命令。
2. 命令（Command）：封装了一次请求，包括请求的接收者和对接收者的操作。命令对象可以执行操作、撤销操作和恢复操作。
3. 接收者（Receiver）：真正执行命令操作的对象。接收者知道如何实现命令所要求的操作。
4. 客户端（Client）：创建请求者、命令和接收者对象，并将它们组装起来。

命令模式的基本思想是将请求封装为一个对象，从而使请求的发送者和接收者之间解耦。通过将请求封装成命令对象，可以将请求的调用者与实现者分离开来，从而实现请求者和接收者之间的解耦。同时，由于命令对象可以被序列化和存储，因此可以支持撤销、重做、事务等功能。

在命令模式中，可以通过多种方式来实现命令的撤销和重做。例如，可以使用栈来保存每个命令的执行历史记录，当需要撤销命令时，从栈中弹出最近的一个命令并执行撤销操作；当需要重做命令时，从栈中弹出最近的一个撤销命令并执行恢复操作。另外，还可以使用备忘录模式来实现命令的撤销和重做。

命令模式的优点包括：

1. 降低系统的耦合度。将命令的请求者和执行者分离，使得它们不需要了解彼此的实现细节，从而降低了系统的耦合度，提高了系统的可维护性和可扩展性。
2. 易于扩展新的命令。由于命令模式将每个命令封装为一个独立的对象，因此很容易添加新的命令，只需要增加新的命令类即可。
3. 支持撤销和重做操作。由于每个命令对象都保存了执行历史记录，因此可以通过撤销和重做操作来实现对命令的撤销和恢复。

命令模式适用于以下场景：

1. 当需要将命令的请求者和执行者解耦时，可以使用命令模式。
2. 当需要支持撤销和重做操作时，可以使用命令模式。
3. 当需要支持宏命令（即由多个命令组成的一个命令）时，可以使用命令模式。
4. 当需要支持命令的排队、记录日志、事务等操作时，可以使用命令模式。例如，在数据库系统中，可以使用命令模式来实现事务操作。

总之，命令模式可以有效地解耦命令的请求者和执行者，提高系统的可维护性和可扩展性。

#include <iostream>
#include <string>
#include <vector>

// 接收者类，执行具体的操作
class Receiver 
public:
    void action1() 
        std::cout << "接收者执行操作1" << std::endl;
    

    void action2() 
        std::cout << "接收者执行操作2" << std::endl;
    
;

// 命令接口
class Command 
public:
    virtual ~Command() 
    virtual void execute() = 0;
;

// 具体命令类，实现命令接口
class ConcreteCommand1 : public Command 
public:
    ConcreteCommand1(Receiver* receiver) : m_receiver(receiver) 
    virtual ~ConcreteCommand1() 

    virtual void execute() 
        m_receiver->action1();
    

private:
    Receiver* m_receiver;
;

class ConcreteCommand2 : public Command 
public:
    ConcreteCommand2(Receiver* receiver) : m_receiver(receiver) 
    virtual ~ConcreteCommand2() 

    virtual void execute() 
        m_receiver->action2();
    

private:
    Receiver* m_receiver;
;

// 宏命令类，由多个命令组成
class MacroCommand : public Command 
public:
    MacroCommand() 
    virtual ~MacroCommand() 

    void addCommand(Command* cmd) 
        m_cmds.push_back(cmd);
    

    virtual void execute() 
        for (auto cmd : m_cmds) 
            cmd->execute();
        
    

private:
    std::vector<Command*> m_cmds;
;

// 命令发起者
class Invoker 
public:
    Invoker() 
    ~Invoker() 

    void setCommand(Command* cmd) 
        m_cmd = cmd;
    

    void executeCommand() 
        m_cmd->execute();
    

private:
    Command* m_cmd;
;

// 客户端代码
int main() 
    Receiver* receiver = new Receiver();
    Command* cmd1 = new ConcreteCommand1(receiver);
    Command* cmd2 = new ConcreteCommand2(receiver);

    MacroCommand* macroCmd = new MacroCommand();
    macroCmd->addCommand(cmd1);
    macroCmd->addCommand(cmd2);

    Invoker invoker;
    invoker.setCommand(macroCmd);
    invoker.executeCommand();

    delete cmd1;
    delete cmd2;
    delete macroCmd;
    delete receiver;

    return 0;

在上面的示例中，我们定义了一个接收者类 Receiver，它负责执行具体的操作。然后，我们定义了两个具体命令类 ConcreteCommand1 和 ConcreteCommand2，它们都继承自 Command 接口，并包含一个指向 Receiver 对象的指针。在 execute 方法中，它们会调用接收者对象的相应方法来执行具体操作。

接着，我们定义了一个宏命令类 MacroCommand，它由多个命令组成，通过 addCommand 方法可以添加命令。在 execute 方法中，它会依次执行每个命令。

然后，我们定义了一个命令发起者 Invoker，它包含一个成员变量 m_cmd，指向一个命令对象，通过 setCommand 方法设置命令对象，通过 executeCommand 方法来执行命令。

最后，我们在客户端代码中创建一个接收者对象和两个具体命令对象，然后将它们添加到一个宏命令对象中。将宏命令对象设置为命令发起者的命令，并执行命令。

这个命令模式实现还包括了宏命令，宏命令是由多个命令组成的一个命令，它可以一次性执行多个命令。在示例中，我们定义了一个 MacroCommand 类来实现宏命令，它包含了一个 std::vector 来存储多个命令对象。在 execute 方法中，它会依次执行每个命令。

命令模式的优点是可以将命令的请求者和命令的执行者解耦，使得请求者和执行者可以独立变化。同时，命令模式也支持撤销和重做操作，只需保存每个命令的执行历史记录即可实现。

需要注意的是，命令模式的实现并不一定要包含接收者和宏命令，这只是一个示例。在实际应用中，可以根据需要进行设计。

• C++函数对象
  Command模式与C++中的函数对象有些类似。但两者定义行为接口的规范有所区别: Command以面向对象中的“接口-实现”来定义行为接口规范，更严格，但有性能损失;C++函数对象以函数签名来定义行为接口规范，更灵活，性能更高。