命令模式（Command Pattern）

定义

命令模式（Command Pattern）是一种行为设计模式，它允许将请求封装成一个对象，从而让你使用不同的请求把客户端与接收者解耦。命令模式的主要目标是实现请求的发送者和接收者之间的解耦，使得发送者不需要知道接收者的具体实现，而接收者也不需要知道请求的具体来源。

在命令模式中，通常包含以下几个角色：

1. Command（命令）：这是一个抽象接口，声明了执行命令的接口。通常包含一个执行命令的execute()方法。

2. ConcreteCommand（具体命令）：实现了Command接口，通常持有一个接收者对象，并定义了具体的执行行为。

3. Invoker（调用者）：负责调用命令对象执行请求。调用者不需要知道具体的接收者是谁，它只与命令对象交互。

4. Receiver（接收者）：真正执行命令的对象。它实现了实际的操作，但是与调用者解耦。

示例

下面是一个简单的C++示例，演示了命令模式的应用：

#include   
#include   
  
// 接收者接口  
class Receiver {  
public:  
    virtual void action() = 0;  
};  
  
// 具体接收者  
class ConcreteReceiver : public Receiver {  
public:  
    void action() override {  
        std::cout << "ConcreteReceiver::action() is called." << std::endl;  
    }  
};  
  
// 命令接口  
class Command {  
public:  
    virtual ~Command() = default;  
    virtual void execute() = 0;  
};  
  
// 具体命令  
class ConcreteCommand : public Command {  
private:  
    std::shared_ptr receiver;  
  
public:  
    ConcreteCommand(std::shared_ptr receiver) : receiver(receiver) {}  
  
    void execute() override {  
        receiver->action();  
    }  
};  
  
// 调用者  
class Invoker {  
private:  
    std::shared_ptr command;  
  
public:  
    Invoker(std::shared_ptr command) : command(command) {}  
  
    void setCommand(std::shared_ptr command) {  
        this->command = command;  
    }  
  
    void executeCommand() {  
        command->execute();  
    }  
};  
  
int main() {  
    // 创建接收者  
    auto receiver = std::make_shared();  
  
    // 创建具体命令，并关联接收者  
    auto command = std::make_shared(receiver);  
  
    // 创建调用者，并设置命令  
    Invoker invoker(command);  
  
    // 调用者执行命令  
    invoker.executeCommand();  
  
    return 0;  
}

在这个示例中，我们定义了Receiver接口和ConcreteReceiver类，Command接口和ConcreteCommand类，以及Invoker类。ConcreteCommand类持有一个Receiver对象的智能指针，并在其execute()方法中调用接收者的action()方法。Invoker类负责调用命令对象的execute()方法。

在main()函数中，我们创建了一个接收者对象、一个具体命令对象，并将接收者传递给命令对象。然后，我们创建了一个调用者对象，并将命令对象设置给它。最后，调用者执行命令，这会间接调用接收者的action()方法。

命令模式的主要优点包括：

1. 解耦：发送者和接收者解耦，发送者只需要知道如何调用命令，而不需要知道命令的具体实现和接收者是谁。

2. 支持撤销和重做：可以轻松地实现命令的撤销和重做功能，只需要在命令对象中保存执行前的状态即可。

3. 支持事务：命令模式可以与事务管理相结合，实现一系列命令的原子性操作。

4. 队列请求：命令可以放入队列中，等待依次执行，实现请求的排队处理。

命令模式的潜在缺点包括：

1. 可能导致某些系统有过多的具体命令类：对于每一个接收者的操作，都需要一个具体的命令类来实现，这可能导致系统中存在大量的命令类。

2. 可能导致某些类型的接收者很难或不可能实现命令：如果接收者的操作非常复杂或不易于封装成命令，则可能无法使用该模式。

命令模式的扩展

1. 宏命令（Composite Command）：
   命令模式可以很容易地支持宏命令，也就是组合多个命令到一个单一命令中。这可以通过创建一个新的命令类，它在其execute()方法中调用多个其他命令的execute()方法来实现。

2. 命令队列（Command Queue）：
   通过使用命令队列，可以轻松地实现命令的延迟执行或批量执行。将命令对象添加到队列中，然后在适当的时间从队列中取出命令并执行。

3. 撤销和重做（Undo and Redo）：
   通过实现命令的撤销和重做功能，可以进一步增强命令模式的实用性。每个命令可以保存其执行前的状态，以便在撤销时恢复；同时，命令也可以记录其执行后的状态，以便在重做时再次执行。

命令模式的适用场景

1. 实现撤销和重做功能：
   当需要支持撤销和重做操作时，命令模式非常有用。例如，在文本编辑器或绘图程序中，用户可能希望撤销或重做最近的更改。

2. 实现日志功能：
   命令模式可以用来记录系统活动的日志。每个命令的执行都可以被记录下来，以便后续分析或重现系统的行为。

3. 队列请求：
   当需要将请求排队执行时，可以使用命令模式。例如，在网络通信中，客户端可以将请求封装成命令对象，并将其发送到服务器，服务器可以在适当的时机执行这些命令。

4. 事务管理：
   在需要执行一系列操作作为单个事务时，命令模式可以很有用。如果事务中的任何命令失败，可以回滚整个事务。

5. 支持快捷键和菜单项：
   在GUI应用程序中，命令模式可以用来处理用户通过快捷键或菜单项触发的操作。每个操作可以封装成一个命令对象，然后将其与相应的快捷键或菜单项关联。

命令模式的潜在缺点

1. 过多的具体命令类：
   正如之前提到的，对于每个接收者的操作，都需要一个具体的命令类来实现。这可能会导致系统中存在大量的命令类，增加了系统的复杂性。

2. 命令的封装成本：
   虽然命令模式提供了很大的灵活性，但每个操作都需要封装成一个命令类，这可能会增加开发成本。需要仔细权衡封装的好处和额外的工作量。

3. 性能考虑：
   在某些情况下，使用命令模式可能会导致性能下降。因为每个命令都需要被实例化，并且可能需要通过反射或其他机制来调用接收者的方法。这些额外的步骤可能会增加执行时间。

总之，命令模式是一个强大而灵活的设计模式，它提供了一种将请求与接收者解耦的方式。然而，在使用该模式时也需要权衡其好处和潜在的缺点。

应用示例

在现实生活中，命令模式经常用于实现一些需要解耦和抽象化操作场景的应用。以下是一个简单的C++生活应用示例，展示了命令模式在餐厅点餐系统中的应用。

在这个系统中，我们有不同类型的菜品（如汉堡、薯条等），顾客（作为调用者）可以通过菜单（命令的集合）来点餐，而厨师（接收者）负责准备菜品。我们使用命令模式来实现顾客点餐和厨师制作菜品之间的解耦。

首先，定义接收者接口和具体接收者类：

#include   
#include   
  
// 接收者接口  
class Cook {  
public:  
    virtual void prepare() = 0;  
};  
  
// 具体接收者：厨师制作汉堡  
class BurgerCook : public Cook {  
public:  
    void prepare() override {  
        std::cout << "Cook is preparing a Burger." << std::endl;  
    }  
};  
  
// 具体接收者：厨师制作薯条  
class FriesCook : public Cook {  
public:  
    void prepare() override {  
        std::cout << "Cook is preparing Fries." << std::endl;  
    }  
};

接下来，定义命令接口和具体命令类：

// 命令接口  
class Order {  
public:  
    virtual ~Order() = default;  
    virtual void execute() = 0;  
};  
  
// 具体命令：点汉堡  
class BurgerOrder : public Order {  
private:  
    std::shared_ptr cook;  
  
public:  
    BurgerOrder(std::shared_ptr cook) : cook(cook) {}  
  
    void execute() override {  
        cook->prepare();  
    }  
};  
  
// 具体命令：点薯条  
class FriesOrder : public Order {  
private:  
    std::shared_ptr cook;  
  
public:  
    FriesOrder(std::shared_ptr cook) : cook(cook) {}  
  
    void execute() override {  
        cook->prepare();  
    }  
};

然后，定义调用者类：

// 调用者：顾客  
class Customer {  
private:  
    std::shared_ptr order;  
  
public:  
    Customer(std::shared_ptr order) : order(order) {}  
  
    void placeOrder() {  
        order->execute();  
    }  
  
    void setOrder(std::shared_ptr order) {  
        this->order = order;  
    }  
};

最后，在main()函数中演示如何使用这个系统：

int main() {  
    // 创建厨师  
    auto burgerCook = std::make_shared();  
    auto friesCook = std::make_shared();  
  
    // 创建具体命令，并关联接收者  
    auto burgerOrder = std::make_shared(burgerCook);  
    auto friesOrder = std::make_shared(friesCook);  
  
    // 创建顾客，并设置命令  
    Customer customer1(burgerOrder);  
    Customer customer2(friesOrder);  
  
    // 顾客点餐  
    customer1.placeOrder();  
    customer2.placeOrder();  
  
    // 如果需要，顾客可以更改他们点的菜品  
    customer1.setOrder(friesOrder);  
    customer1.placeOrder(); // 现在顾客1点了薯条  
  
    return 0;  
}

在这个示例中，顾客通过Customer类来点餐，他们不直接与厨师交互。顾客通过placeOrder()方法执行命令，而命令对象（BurgerOrder或FriesOrder）负责调用相应厨师的prepare()方法。这样，顾客和厨师之间的交互被命令对象解耦了。

这个示例展示了命令模式在现实世界中的一个简单应用，即餐厅点餐系统。通过命令模式，我们可以轻松地更改顾客点的菜品，添加新的菜品类型，或者实现撤销和重做功能等。

在餐厅点餐系统中实现撤销和重做功能

我们需要对命令模式进行一些扩展。具体来说，我们需要维护一个命令历史记录，这样我们就可以回退到前一个状态或重新执行之前的命令。

以下是一个扩展后的C++示例，展示了如何在餐厅点餐系统中实现撤销和重做功能：

#include   
#include   
#include   
#include   
  
// 接收者接口  
class Cook {  
public:  
    virtual void prepare() = 0;  
    virtual ~Cook() = default;  
};  
  
// 具体接收者：厨师制作汉堡  
class BurgerCook : public Cook {  
public:  
    void prepare() override {  
        std::cout << "Cook is preparing a Burger." << std::endl;  
    }  
};  
  
// 命令接口  
class Order {  
public:  
    virtual ~Order() = default;  
    virtual void execute() = 0;  
    virtual void undo() = 0; // 撤销操作  
};  
  
// 具体命令：点汉堡  
class BurgerOrder : public Order {  
private:  
    std::shared_ptr cook;  
    bool isPrepared = false; // 记录菜品是否已制作  
  
public:  
    BurgerOrder(std::shared_ptr cook) : cook(cook) {}  
  
    void execute() override {  
        if (!isPrepared) {  
            cook->prepare();  
            isPrepared = true;  
        }  
    }  
  
    void undo() override {  
        if (isPrepared) {  
            // 假设有一个方法可以让厨师取消制作  
            // cook->cancelPreparation();  
            std::cout << "Burger preparation cancelled." << std::endl;  
            isPrepared = false;  
        }  
    }  
};  
  
// 调用者：顾客  
class Customer {  
private:  
    std::shared_ptr currentOrder;  
    std::vector> orderHistory; // 命令历史记录  
    size_t currentIndex = 0; // 当前命令在历史记录中的索引  
  
public:  
    void placeOrder(std::shared_ptr order) {  
        if (currentOrder) {  
            orderHistory.push_back(currentOrder);  
        }  
        currentOrder = order;  
        currentOrder->execute();  
        currentIndex = orderHistory.size() - 1;  
    }  
  
    void undo() {  
        if (currentIndex > 0) {  
            currentIndex--;  
            orderHistory[currentIndex]->undo();  
        } else {  
            std::cout << "No more commands to undo." << std::endl;  
        }  
    }  
  
    void redo() {  
        if (currentIndex < orderHistory.size() - 1) {  
            currentIndex++;  
            orderHistory[currentIndex]->execute();  
        } else {  
            std::cout << "No more commands to redo." << std::endl;  
        }  
    }  
};  
  
int main() {  
    // 创建厨师  
    auto burgerCook = std::make_shared();  
  
    // 创建具体命令  
    auto burgerOrder = std::make_shared(burgerCook);  
  
    // 创建顾客  
    Customer customer;  
  
    // 顾客点餐  
    customer.placeOrder(burgerOrder);  
  
    // 顾客撤销操作  
    customer.undo();  
  
    // 顾客重做操作  
    customer.redo();  
  
    return 0;  
}

在这个扩展后的示例中，我们做了以下几点更改：

1. 在Order接口中添加了一个undo()方法，用于实现撤销功能。

2. 在BurgerOrder类中实现了undo()方法，它简单地模拟了撤销制作汉堡的过程（在实际应用中，可能需要调用厨师的某个方法来真正取消制作）。

3. 在Customer类中，我们添加了一个orderHistory向量来存储命令历史记录，以及一个currentIndex变量来跟踪当前命令在历史记录中的位置。

4. Customer类现在有了undo()和redo()方法，它们分别用于回退到前一个命令和重新执行下一个命令。

这个扩展后的系统允许顾客在点餐后进行撤销和重做操作，从而提供了一种简单的命令历史管理功能。在实际应用中，撤销和重做功能可能需要更复杂的逻辑来处理多个命令之间的依赖关系和状态变化。