阿丁的猫1. 命令模式的核心概念与应用场景
在C++开发中，命令模式（Command Pattern）是一种行为型设计模式，它将请求封装为独立的对象，使你可以参数化客户端对象的不同请求、队列或日志请求，并支持可撤销的操作。这种模式的核心思想是将"做什么"（具体操作）与"谁来做"（调用者）解耦。
1.1 命令模式的典型结构
一个标准的命令模式实现通常包含以下几个关键组件：
- Command（命令接口）：声明执行操作的接口
- ConcreteCommand（具体命令）：实现命令接口，绑定接收者与动作
- Invoker（调用者）：要求命令执行请求
- Receiver（接收者）：知道如何执行与请求相关的操作
- Client（客户端）：创建具体命令对象并设置其接收者
这种结构在GUI菜单系统、事务处理系统、宏录制等场景中特别有用。比如在游戏开发中，玩家的每个操作（移动、攻击、使用道具）都可以封装为命令对象，方便实现撤销/重做功能。
1.2 C++实现命令模式的优势
C++的面向对象特性和内存控制能力使其成为实现命令模式的理想选择：
- 多态支持：通过基类指针调用不同子类的execute()方法
- 内存控制：可以精确控制命令对象的生命周期
- 性能优化：可以使用移动语义减少命令传递的开销
- 模板支持：可以创建泛型命令模板类
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 基础命令模式实现
2.1 基本接口定义
首先定义命令接口，这是所有具体命令的基类：
cpp复制class Command {
public:
virtual ~Command() = default;
virtual void execute() = 0;
virtual void undo() = 0; // 支持撤销操作
};
2.2 具体命令实现
假设我们有一个文档编辑器，实现一个插入文本的命令：
cpp复制class InsertCommand : public Command {
public:
InsertCommand(Document& doc, const std::string& text, size_t pos)
: document(doc), text(text), position(pos) {}
void execute() override {
document.insert(text, position);
}
void undo() override {
document.erase(position, text.length());
}
private:
Document& document;
std::string text;
size_t position;
};
2.3 调用者实现
调用者类负责触发命令执行：
cpp复制class MenuItem {
public:
void setCommand(std::unique_ptr<Command> cmd) {
command = std::move(cmd);
}
void click() {
if (command) {
command->execute();
commandHistory.push(std::move(command));
}
}
void undoLastCommand() {
if (!commandHistory.empty()) {
auto cmd = std::move(commandHistory.top());
cmd->undo();
commandHistory.pop();
}
}
private:
std::unique_ptr<Command> command;
std::stack<std::unique_ptr<Command>> commandHistory;
};
3. 高级命令模式技巧
3.1 使用智能指针管理命令生命周期
在现代C++中，我们可以利用智能指针来管理命令对象的生命周期：
cpp复制using CommandPtr = std::unique_ptr<Command>;
class CommandManager {
public:
void executeCommand(CommandPtr cmd) {
cmd->execute();
undoStack.push(std::move(cmd));
redoStack = std::stack<CommandPtr>(); // 清空重做栈
}
void undo() {
if (!undoStack.empty()) {
auto cmd = std::move(undoStack.top());
cmd->undo();
redoStack.push(std::move(cmd));
undoStack.pop();
}
}
void redo() {
if (!redoStack.empty()) {
auto cmd = std::move(redoStack.top());
cmd->execute();
undoStack.push(std::move(cmd));
redoStack.pop();
}
}
private:
std::stack<CommandPtr> undoStack;
std::stack<CommandPtr> redoStack;
};
3.2 使用lambda表达式简化命令创建
C++11引入的lambda表达式可以简化命令对象的创建：
cpp复制template <typename Func, typename UndoFunc>
class LambdaCommand : public Command {
public:
LambdaCommand(Func f, UndoFunc uf)
: func(f), undoFunc(uf) {}
void execute() override { func(); }
void undo() override { undoFunc(); }
private:
Func func;
UndoFunc undoFunc;
};
// 使用示例
auto cmd = std::make_unique<LambdaCommand>(
[] { std::cout << "Executing command\n"; },
[] { std::cout << "Undoing command\n"; }
);
3.3 宏命令实现
宏命令可以组合多个命令作为一个命令执行：
cpp复制class MacroCommand : public Command {
public:
void addCommand(std::unique_ptr<Command> cmd) {
commands.push_back(std::move(cmd));
}
void execute() override {
for (auto& cmd : commands) {
cmd->execute();
}
}
void undo() override {
for (auto it = commands.rbegin(); it != commands.rend(); ++it) {
(*it)->undo();
}
}
private:
std::vector<std::unique_ptr<Command>> commands;
};
4. 命令模式在实际项目中的应用
4.1 游戏开发中的输入处理
在游戏开发中，命令模式常用于处理玩家输入：
cpp复制class InputHandler {
public:
std::unique_ptr<Command> handleInput() {
if (isPressed(BUTTON_X)) return buttonX_;
if (isPressed(BUTTON_Y)) return buttonY_;
if (isPressed(BUTTON_A)) return buttonA_;
if (isPressed(BUTTON_B)) return buttonB_;
return nullptr;
}
// 绑定命令到按钮
void bindButtonX(std::unique_ptr<Command> cmd) { buttonX_ = std::move(cmd); }
void bindButtonY(std::unique_ptr<Command> cmd) { buttonY_ = std::move(cmd); }
void bindButtonA(std::unique_ptr<Command> cmd) { buttonA_ = std::move(cmd); }
void bindButtonB(std::unique_ptr<Command> cmd) { buttonB_ = std::move(cmd); }
private:
std::unique_ptr<Command> buttonX_;
std::unique_ptr<Command> buttonY_;
std::unique_ptr<Command> buttonA_;
std::unique_ptr<Command> buttonB_;
bool isPressed(Button button) { /* 检测按钮状态 */ }
};
4.2 事务处理系统
命令模式非常适合实现事务处理系统，确保操作的原子性：
cpp复制class Transaction {
public:
void addCommand(std::unique_ptr<Command> cmd) {
commands.push_back(std::move(cmd));
}
bool commit() {
try {
for (auto& cmd : commands) {
cmd->execute();
}
return true;
} catch (...) {
rollback();
return false;
}
}
void rollback() {
for (auto it = commands.rbegin(); it != commands.rend(); ++it) {
(*it)->undo();
}
}
private:
std::vector<std::unique_ptr<Command>> commands;
};
4.3 异步命令队列
命令模式可以轻松扩展为异步执行：
cpp复制class AsyncCommandQueue {
public:
void addCommand(std::unique_ptr<Command> cmd) {
std::lock_guard<std::mutex> lock(queueMutex_);
queue_.push(std::move(cmd));
condition_.notify_one();
}
void startProcessing() {
processorThread_ = std::thread([this] {
while (running_) {
std::unique_ptr<Command> cmd;
{
std::unique_lock<std::mutex> lock(queueMutex_);
condition_.wait(lock, [this] {
return !queue_.empty() || !running_;
});
if (!running_) break;
cmd = std::move(queue_.front());
queue_.pop();
}
cmd->execute();
}
});
}
void stopProcessing() {
running_ = false;
condition_.notify_all();
if (processorThread_.joinable()) {
processorThread_.join();
}
}
private:
std::queue<std::unique_ptr<Command>> queue_;
std::mutex queueMutex_;
std::condition_variable condition_;
std::thread processorThread_;
bool running_ = true;
};
5. 命令模式的性能优化
5.1 命令对象池
频繁创建销毁命令对象可能影响性能，可以使用对象池技术：
cpp复制template <typename T>
class CommandPool {
public:
template <typename... Args>
std::unique_ptr<T, std::function<void(T*)>> acquire(Args&&... args) {
std::unique_ptr<T, std::function<void(T*)>> ptr(
pool_.empty() ? new T(std::forward<Args>(args)...) : pool_.back().release(),
[this](T* t) {
pool_.push_back(std::unique_ptr<T>(t));
}
);
if (!pool_.empty()) {
pool_.pop_back();
}
return ptr;
}
private:
std::vector<std::unique_ptr<T>> pool_;
};
5.2 使用移动语义减少拷贝
在命令传递过程中，使用移动语义可以显著提高性能：
cpp复制class BufferCommand : public Command {
public:
explicit BufferCommand(std::vector<uint8_t>&& data)
: data_(std::move(data)) {}
void execute() override {
// 使用data_
}
void undo() override {
// 撤销操作
}
private:
std::vector<uint8_t> data_;
};
5.3 命令的轻量级实现
对于简单命令，可以使用函数指针或std::function减少开销：
cpp复制class LightweightCommand : public Command {
public:
using CommandFunc = std::function<void()>;
LightweightCommand(CommandFunc execute, CommandFunc undo)
: execute_(std::move(execute)), undo_(std::move(undo)) {}
void execute() override { execute_(); }
void undo() override { undo_(); }
private:
CommandFunc execute_;
CommandFunc undo_;
};
6. 命令模式与其他设计模式的结合
6.1 命令模式与组合模式
结合组合模式可以创建复杂的命令结构：
cpp复制class CompositeCommand : public Command {
public:
void add(std::unique_ptr<Command> cmd) {
children_.push_back(std::move(cmd));
}
void execute() override {
for (auto& child : children_) {
child->execute();
}
}
void undo() override {
for (auto it = children_.rbegin(); it != children_.rend(); ++it) {
(*it)->undo();
}
}
private:
std::vector<std::unique_ptr<Command>> children_;
};
6.2 命令模式与备忘录模式
使用备忘录模式可以更好地支持命令的撤销操作：
cpp复制class Memento {
public:
virtual ~Memento() = default;
};
class Originator {
public:
std::unique_ptr<Memento> createMemento() {
return std::make_unique<ConcreteMemento>(state_);
}
void restoreFromMemento(const Memento* memento) {
if (auto cm = dynamic_cast<const ConcreteMemento*>(memento)) {
state_ = cm->getState();
}
}
void setState(int state) { state_ = state; }
int getState() const { return state_; }
private:
class ConcreteMemento : public Memento {
public:
ConcreteMemento(int state) : state_(state) {}
int getState() const { return state_; }
private:
int state_;
};
int state_ = 0;
};
class StateChangeCommand : public Command {
public:
StateChangeCommand(Originator& originator, int newState)
: originator_(originator), newState_(newState) {}
void execute() override {
memento_ = originator_.createMemento();
originator_.setState(newState_);
}
void undo() override {
originator_.restoreFromMemento(memento_.get());
}
private:
Originator& originator_;
std::unique_ptr<Memento> memento_;
int newState_;
};
6.3 命令模式与观察者模式
结合观察者模式可以实现命令执行的通知机制：
cpp复制class CommandObserver {
public:
virtual ~CommandObserver() = default;
virtual void onCommandExecuted(const Command& cmd) = 0;
virtual void onCommandUndone(const Command& cmd) = 0;
};
class ObservableCommand : public Command {
public:
void addObserver(CommandObserver* observer) {
observers_.push_back(observer);
}
void removeObserver(CommandObserver* observer) {
observers_.erase(
std::remove(observers_.begin(), observers_.end(), observer),
observers_.end()
);
}
void execute() override {
Command::execute();
notifyExecuted();
}
void undo() override {
Command::undo();
notifyUndone();
}
protected:
void notifyExecuted() {
for (auto observer : observers_) {
observer->onCommandExecuted(*this);
}
}
void notifyUndone() {
for (auto observer : observers_) {
observer->onCommandUndone(*this);
}
}
private:
std::vector<CommandObserver*> observers_;
};
7. 命令模式的测试与调试
7.1 单元测试策略
为命令模式编写有效的单元测试：
cpp复制TEST(CommandPatternTest, BasicCommandExecution) {
MockReceiver receiver;
EXPECT_CALL(receiver, performAction()).Times(1);
ConcreteCommand cmd(receiver);
cmd.execute();
}
TEST(CommandPatternTest, UndoFunctionality) {
MockReceiver receiver;
EXPECT_CALL(receiver, undoAction()).Times(1);
ConcreteCommand cmd(receiver);
cmd.execute();
cmd.undo();
}
TEST(CommandPatternTest, MacroCommandExecutionOrder) {
testing::Sequence seq;
MockReceiver receiver;
EXPECT_CALL(receiver, performAction(1)).InSequence(seq);
EXPECT_CALL(receiver, performAction(2)).InSequence(seq);
EXPECT_CALL(receiver, performAction(3)).InSequence(seq);
MacroCommand macro;
macro.addCommand(std::make_unique<ConcreteCommand>(receiver, 1));
macro.addCommand(std::make_unique<ConcreteCommand>(receiver, 2));
macro.addCommand(std::make_unique<ConcreteCommand>(receiver, 3));
macro.execute();
}
7.2 调试技巧
调试命令模式时的实用技巧：
- 命令日志：记录所有执行的命令及其参数
- 序列号标记：为每个命令分配唯一ID，便于追踪
- 状态检查点：在关键命令执行前后保存系统状态
- 回放机制：能够重新执行命令序列进行问题复现
cpp复制class LoggingCommand : public Command {
public:
LoggingCommand(std::unique_ptr<Command> cmd, std::ostream& log)
: wrapped_(std::move(cmd)), log_(log) {}
void execute() override {
log_ << "Executing command at " << std::chrono::system_clock::now() << "\n";
wrapped_->execute();
}
void undo() override {
log_ << "Undoing command at " << std::chrono::system_clock::now() << "\n";
wrapped_->undo();
}
private:
std::unique_ptr<Command> wrapped_;
std::ostream& log_;
};
7.3 性能分析
分析命令模式性能的关键指标：
- 命令创建开销：测量命令对象的构造和析构时间
- 执行延迟：记录从命令创建到执行完成的时间
- 内存占用：监控命令队列的内存使用情况
- 撤销开销：测量撤销操作的时间成本
可以使用C++的
cpp复制auto start = std::chrono::high_resolution_clock::now();
command->execute();
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "Command execution took " << duration.count() << " microseconds\n";
8. 命令模式的最佳实践与常见陷阱
8.1 最佳实践
- 保持命令轻量：命令对象应该只包含执行操作所需的最小状态
- 实现完备的撤销：确保每个命令都有对应的撤销操作
- 考虑线程安全：如果命令可能在多线程环境中使用，确保线程安全
- 限制命令队列大小：防止无限增长导致内存问题
- 使用智能指针：自动管理命令对象的生命周期
8.2 常见陷阱与解决方案
-
内存泄漏：
- 问题：忘记删除命令对象
- 解决：始终使用智能指针管理命令
-
不完全的撤销操作：
- 问题：撤销后系统状态不一致
- 解决：在命令中保存足够的状态信息
-
命令膨胀：
- 问题：太多小命令类导致代码臃肿
- 解决：使用模板或lambda简化命令创建
-
性能瓶颈：
- 问题：命令执行成为性能瓶颈
- 解决：考虑异步执行或批量处理
-
循环依赖：
- 问题：命令与接收者之间循环引用
- 解决：使用弱引用或中介者模式
8.3 设计决策指南
在设计命令模式实现时，需要考虑以下决策点：
-
命令粒度：
- 细粒度：每个小操作一个命令（更灵活）
- 粗粒度：复合操作一个命令（更高效）
-
撤销实现：
- 反向操作：执行相反操作
- 状态恢复：保存并恢复之前状态
-
命令存储：
- 内存：快速但易失
- 持久化：可恢复但较慢
-
执行时机：
- 同步：立即执行
- 异步：延迟执行
-
命令参数：
- 构造时传入：更安全
- 执行时传入：更灵活
在实际项目中，我通常会根据具体需求在这些选项之间做出权衡。例如，在需要严格保证操作顺序的系统中，我倾向于使用同步执行的细粒度命令；而在需要高性能批处理的场景中，则选择异步执行的粗粒度复合命令。