C++设计模式行为模式——命令模式

目录

1. 引言
2. 命令模式概述
3. 命令模式的组成
   • 命令接口
   • 具体命令类
   • 调用者（Invoker）
   • 接收者（Receiver）
4. 命令模式的应用场景
   • 事件驱动的GUI编程
   • 多种操作的批量执行
   • 可撤销的操作
5. C++中实现命令模式
   • 基本代码示例
   • 扩展示例：带参数的命令
   • 撤销功能的实现
6. 命令模式的优缺点
   • 优点
   • 缺点
7. 总结

引言

设计模式是一种解决常见软件设计问题的通用方法，它提供了一种在不同情况下可以重复使用的解决方案。在众多设计模式中，行为模式侧重于处理对象之间的交互和责任分配。命令模式（Command Pattern）是行为模式之一，它允许请求封装为对象，并通过这些对象来参数化客户端请求的各种操作，从而解耦调用者与执行者之间的关系。

命令模式非常适合在一些复杂的系统中，其中需要对请求进行排队、记录日志、撤销操作或支持操作的多次调用。通过将请求封装为命令对象，命令模式有效地将请求的发送者与执行者进行解耦，增加了系统的灵活性和可扩展性。

在本篇文章中，我们将深入探讨命令模式的基本概念，分析其结构和应用场景，并通过C++代码示例帮助大家理解如何在实际项目中实现命令模式。

命令模式概述

命令模式的核心思想是将请求（或操作）封装成一个命令对象（Command），这样调用者（Invoker）就不需要了解请求的具体执行细节，只需要通过调用命令对象的方法来执行操作。命令模式使得请求的发送者和接收者解耦，命令对象独立于请求的执行者，并且可以灵活地存储、传递和执行。

命令模式的定义

命令模式定义了一种将请求封装成对象的方式，从而使得用户可以用不同的请求对客户端进行参数化。命令模式能够把一个请求或操作封装成对象，使得可以将不同的请求动态传递给不同的接收者。它可以在请求者和接收者之间提供解耦，同时允许对请求进行处理、排队、记录日志，甚至支持撤销操作。

命令模式通常涉及以下几个角色：

• 命令接口（Command）：声明执行操作的接口。
• 具体命令类（ConcreteCommand）：实现命令接口，定义具体的请求，并调用接收者的相应方法。
• 调用者（Invoker）：请求命令的对象，负责发起请求，但不知道请求如何被执行。
• 接收者（Receiver）：处理请求的实际工作对象，知道如何执行与请求相关的操作。

命令模式的组成

命令模式通常由以下几个部分组成：

1. 命令接口（Command）

命令接口通常定义一个执行操作的方法，所有具体命令类都需要实现该接口，以便不同的命令类可以通过统一的接口进行调用。

cppCopy Code
class Command {
public:
    virtual void execute() = 0;
    virtual ~Command() = default;
};

2. 具体命令类（ConcreteCommand）

具体命令类是命令模式的核心，它实现了命令接口，并定义了请求的具体操作。每个具体命令类都需要持有一个接收者对象的引用，并在执行时调用接收者的方法来完成请求。

cppCopy Code
class Receiver {
public:
    void action() {
        std::cout << "Receiver is performing the action." << std::endl;
    }
};

class ConcreteCommand : public Command {
private:
    Receiver* receiver;
public:
    ConcreteCommand(Receiver* r) : receiver(r) {}

    void execute() override {
        receiver->action();
    }
};

3. 调用者（Invoker）

调用者持有一个命令对象并在适当的时机触发命令的执行。调用者通常是请求的发起者，负责调度命令对象的执行，但不关心命令如何执行。

cppCopy Code
class Invoker {
private:
    Command* command;
public:
    void setCommand(Command* cmd) {
        command = cmd;
    }

    void invoke() {
        if (command) {
            command->execute();
        }
    }
};

4. 接收者（Receiver）

接收者知道如何处理请求的实际执行逻辑。它通常是一个有具体业务逻辑的对象，命令对象会调用接收者的方法来完成具体的操作。

cppCopy Code
class Receiver {
public:
    void action() {
        std::cout << "Receiver is performing the action." << std::endl;
    }
};

命令模式的应用场景

命令模式有广泛的应用场景，以下是一些典型的应用场景：

1. 事件驱动的GUI编程

在图形用户界面（GUI）编程中，命令模式常常用于将用户的操作（如按钮点击、菜单选择等）封装为命令对象。这样，GUI组件（如按钮、菜单项）就不需要直接与业务逻辑进行耦合，而是通过命令对象将请求转发给合适的处理器。

例如，当用户点击一个按钮时，可以创建一个命令对象，并通过调用命令对象的execute方法来触发具体的操作。这种设计使得UI组件与业务逻辑解耦，便于修改和扩展。

2. 多种操作的批量执行

命令模式还适用于将多个操作封装成一个命令序列，并允许这些操作按顺序批量执行。例如，在某些操作中，用户可能需要在不同的时间或条件下执行一组相同的操作。通过命令模式，可以将这些操作封装在一组命令对象中，并通过调用这些对象的execute方法来批量执行。

3. 可撤销的操作

命令模式特别适合用于需要撤销操作的场景。例如，在文本编辑器中，当用户进行一系列编辑操作时，系统需要能够撤销这些操作。每个操作可以封装为一个命令对象，并且命令对象可以实现撤销方法，从而实现对操作的撤销功能。

通过命令模式，撤销操作的实现变得非常简单。每个命令对象保存操作的状态，并能够撤销自己执行过的操作。

C++中实现命令模式

接下来，我们将通过C++代码示例来演示如何实现命令模式。

基本代码示例

首先，我们先实现一个简单的命令模式示例，包含一个接收者、一个命令类、一个调用者和一个客户端。

cppCopy Code
#include <iostream>

// Command interface
class Command {
public:
    virtual void execute() = 0;
    virtual ~Command() = default;
};

// Receiver class
class Receiver {
public:
    void action() {
        std::cout << "Receiver is performing the action." << std::endl;
    }
};

// Concrete Command class
class ConcreteCommand : public Command {
private:
    Receiver* receiver;
public:
    ConcreteCommand(Receiver* r) : receiver(r) {}

    void execute() override {
        receiver->action();
    }
};

// Invoker class
class Invoker {
private:
    Command* command;
public:
    void setCommand(Command* cmd) {
        command = cmd;
    }

    void invoke() {
        if (command) {
            command->execute();
        }
    }
};

// Client code
int main() {
    Receiver* receiver = new Receiver();
    Command* command = new ConcreteCommand(receiver);
    Invoker invoker;

    invoker.setCommand(command);
    invoker.invoke();

    delete receiver;
    delete command;
    return 0;
}

扩展示例：带参数的命令

在某些场景下，命令可能需要携带参数。我们可以通过修改命令接口和具体命令类来实现这一点。

cppCopy Code
class CommandWithParam {
public:
    virtual void execute(const std::string& param) = 0;
    virtual ~CommandWithParam() = default;
};

class Receiver {
public:
    void action(const std::string& param) {
        std::cout << "Receiver is performing the action with " << param << std::endl;
    }
};

class ConcreteCommandWithParam : public CommandWithParam {
private:
    Receiver* receiver;
public:
    ConcreteCommandWithParam(Receiver* r) : receiver(r) {}

    void execute(const std::string& param) override {
        receiver->action(param);
    }
};