命令模式（Command）

命令模式（Command Pattern）是一种行为设计模式，它将请求封装为对象，从而使得可以用不同的请求对客户进行参数化，对请求排队或记录日志，以及支持可撤销的操作。

命令模式的主要特点：

1. 封装请求

命令模式将请求封装成一个对象，这样就可以用不同的请求对客户端进行参数化。命令对象将调用操作的对象与实现这些操作的对象解耦。

2. 解耦调用者和接收者

调用者只需要知道如何发送命令，而不需要知道命令是如何被处理的。接收者则负责执行命令。这样，调用者和接收者之间的耦合度降低，增强了系统的灵活性。

3. 支持撤销和重做

命令模式可以很容易地实现命令的撤销和重做功能。通过在命令对象中实现undo方法，可以将对象恢复到命令执行前的状态。通过记录命令执行的历史，可以支持命令的重做功能。

4. 支持命令的排队和记录日志

命令可以被存储在队列中进行排队，按照一定的顺序依次执行。还可以将命令及其执行记录下来，用于审计和回放。

5. 组合命令

可以将多个命令组合成一个复杂的命令，通过组合命令来封装一系列复杂的操作。这使得系统可以方便地构建宏命令，从而执行一系列操作。

6. 易于扩展

新命令可以很容易地添加到系统中，因为增加一个新的命令不会影响其他类的实现。只需要实现新的命令类，并在需要时使用它们即可。

命令模式的实现的日志流程示例：

使用命令模式的设计模式可以帮助我们记录命令日志，并且可以方便地执行、撤销和重做命令。以下是一个简单的C++示例，展示了如何实现命令模式并记录命令日志。

首先，我们需要定义命令的接口：

// Command.h
#ifndef COMMAND_H
#define COMMAND_H

#include <string>

class Command {
public:
    virtual ~Command() {}
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual std::string getName() const = 0;
};

#endif // COMMAND_H

接着，我们可以定义一个具体的命令类，例如打开文件命令：
 

// OpenFileCommand.h
#ifndef OPENFILECOMMAND_H
#define OPENFILECOMMAND_H

#include "Command.h"
#include <iostream>
#include <fstream>

class OpenFileCommand : public Command {
public:
    OpenFileCommand(const std::string &filename) : filename(filename) {}

    void execute() override {
        std::cout << "Opening file: " << filename << std::endl;
        // 模拟打开文件的操作
        std::ifstream file(filename);
        if (file.is_open()) {
            std::cout << "File opened successfully." << std::endl;
            file.close();
        } else {
            std::cout << "Failed to open file." << std::endl;
        }
    }

    void undo() override {
        std::cout << "Closing file: " << filename << std::endl;
        // 模拟关闭文件的操作
    }

    std::string getName() const override {
        return "OpenFileCommand";
    }

private:
    std::string filename;
};

#endif // OPENFILECOMMAND_H

然后，我们需要一个命令管理器来记录和管理命令的执行和撤销：

// CommandManager.h
#ifndef COMMANDMANAGER_H
#define COMMANDMANAGER_H

#include "Command.h"
#include <vector>
#include <memory>

class CommandManager {
public:
    void executeCommand(std::unique_ptr<Command> command) {
        command->execute();
        executedCommands.push_back(std::move(command));
    }

    void undoCommand() {
        if (!executedCommands.empty()) {
            auto command = std::move(executedCommands.back());
            executedCommands.pop_back();
            command->undo();
            undoneCommands.push_back(std::move(command));
        }
    }

    void redoCommand() {
        if (!undoneCommands.empty()) {
            auto command = std::move(undoneCommands.back());
            undoneCommands.pop_back();
            command->execute();
            executedCommands.push_back(std::move(command));
        }
    }

    void logCommands() const {
        std::cout << "Executed Commands:" << std::endl;
        for (const auto &command : executedCommands) {
            std::cout << "- " << command->getName() << std::endl;
        }
        std::cout << "Undone Commands:" << std::endl;
        for (const auto &command : undoneCommands) {
            std::cout << "- " << command->getName() << std::endl;
        }
    }

private:
    std::vector<std::unique_ptr<Command>> executedCommands;
    std::vector<std::unique_ptr<Command>> undoneCommands;
};

#endif // COMMANDMANAGER_H

最后，我们编写一个主程序来测试上述实现：

// main.cpp
#include "OpenFileCommand.h"
#include "CommandManager.h"
#include <memory>

int main() {
    CommandManager commandManager;

    auto openFileCommand = std::make_unique<OpenFileCommand>("example.txt");
    commandManager.executeCommand(std::move(openFileCommand));

    commandManager.logCommands();

    commandManager.undoCommand();
    commandManager.logCommands();

    commandManager.redoCommand();
    commandManager.logCommands();

    return 0;
}

编译并运行这段代码，你将看到命令的执行、撤销和重做日志输出。通过使用命令模式，我们可以方便地管理和记录命令的执行历史，为实现复杂的功能提供了良好的扩展性。