链接：C++ 设计模式
链接：C++ 设计模式 - 访问器模式

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

1. 问题分析

在开发中，我们经常需要向某个对象发送请求，但我们希望请求的发送者和接收者解耦。我们还可能需要对请求进行排队、记录日志，甚至支持撤销操作。

命令模式通过将请求封装成一个独立的对象，使得请求的发送者和接收者解耦。每个命令对象都实现一个统一的接口，包含执行请求的方法。这样，我们可以用不同的命令对象对客户进行参数化，并且可以很容易地扩展新的命令。

2.实现步骤

1. 定义命令接口（Command）：声明执行请求的方法。
2. 实现具体命令类（ConcreteCommand）：实现命令接口，执行具体的请求。
3. 定义接收者类（Receiver）：包含执行具体请求的方法。
4. 定义调用者类（Invoker）：持有命令对象，并在某个时刻调用命令对象的执行方法。
5. 客户端代码（Client）：创建具体命令对象，并将其传递给调用者。

3.代码示例

以机器人示例。

3.1.定义命令接口

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

3.2.实现具体命令类

// 接收者类：机器人
class Robot {
 public:
  void moveForward() { std::cout << "Robot moves forward" << std::endl; }

  void moveBackward() { std::cout << "Robot moves backward" << std::endl; }

  void turnLeft() { std::cout << "Robot turns left" << std::endl; }

  void turnRight() { std::cout << "Robot turns right" << std::endl; }
};

3.3.定义接收者类

// 具体命令类：前进
class MoveForwardCommand : public Command {
 public:
  MoveForwardCommand(Robot* robot) : robot_(robot) {}

  void execute() override { robot_->moveForward(); }

 private:
  Robot* robot_;
};

// 具体命令类：后退
class MoveBackwardCommand : public Command {
 public:
  MoveBackwardCommand(Robot* robot) : robot_(robot) {}

  void execute() override { robot_->moveBackward(); }

 private:
  Robot* robot_;
};

// 具体命令类：左转
class TurnLeftCommand : public Command {
 public:
  TurnLeftCommand(Robot* robot) : robot_(robot) {}

  void execute() override { robot_->turnLeft(); }

 private:
  Robot* robot_;
};

// 具体命令类：右转
class TurnRightCommand : public Command {
 public:
  TurnRightCommand(Robot* robot) : robot_(robot) {}

  void execute() override { robot_->turnRight(); }

 private:
  Robot* robot_;
};

3.4.定义调用者类

// 调用者类：遥控器
class RemoteControl {
 public:
  void setCommand(Command* command) { command_ = command; }

  void pressButton() {
    if (command_) {
      command_->execute();
    }
  }

 private:
  Command* command_ = nullptr;
};

3.5.客户端代码

int main() {
  // 创建接收者对象
  Robot robot;

  // 创建具体命令对象
  MoveForwardCommand moveForwardCommand(&robot);
  MoveBackwardCommand moveBackwardCommand(&robot);
  TurnLeftCommand turnLeftCommand(&robot);
  TurnRightCommand turnRightCommand(&robot);

  // 创建调用者对象
  RemoteControl remoteControl;

  // 设置命令并按下按钮
  remoteControl.setCommand(&moveForwardCommand);
  remoteControl.pressButton();

  remoteControl.setCommand(&moveBackwardCommand);
  remoteControl.pressButton();

  remoteControl.setCommand(&turnLeftCommand);
  remoteControl.pressButton();

  remoteControl.setCommand(&turnRightCommand);
  remoteControl.pressButton();

  return 0;
}

4.C++函数对象

函数对象是一个重载了 operator() 的类，其实例可以像函数一样被调用。函数对象的主要目的是将行为封装到对象中，使得对象可以像函数一样被调用。函数对象强调的是行为的封装和灵活性。

4.1.定义函数对象类

// 函数对象类：前进
class MoveForward {
 public:
  MoveForward(Robot* robot) : robot_(robot) {}

  void operator()() { robot_->moveForward(); }

 private:
  Robot* robot_;
};

// 函数对象类：后退
class MoveBackward {
 public:
  MoveBackward(Robot* robot) : robot_(robot) {}

  void operator()() { robot_->moveBackward(); }

 private:
  Robot* robot_;
};

4.2.定义调用者类

// 调用者类：遥控器
class RemoteControl {
 public:
  void setCommand(std::function<void()> command) { command_ = command; }

  void pressButton() {
    if (command_) {
      command_();
    }
  }

 private:
  std::function<void()> command_;
};

4.3.客户端代码

int main() {
  // 创建接收者对象
  Robot robot;

  // 创建函数对象
  MoveForward moveForward(&robot);
  MoveBackward moveBackward(&robot);

  // 创建调用者对象
  RemoteControl remoteControl;

  // 设置命令并按下按钮
  remoteControl.setCommand(moveForward);
  remoteControl.pressButton();

  remoteControl.setCommand(moveBackward);
  remoteControl.pressButton();

  return 0;
}

5.命令模式与函数对象的对比

5.1. 相似点

1. 封装行为：命令模式和函数对象都可以用于封装行为，使得行为可以像对象一样被传递和调用。
2. 解耦：两者都可以实现请求的发送者和接收者的解耦。

5.2. 不同点

1. 设计意图：

   • 命令模式：主要用于将请求封装成对象，从而支持请求的排队、记录日志、撤销和重做等操作。
   • 函数对象：主要用于将行为封装到对象中，使得对象可以像函数一样被调用，强调行为的灵活性和可组合性。

2. 结构复杂度：

   • 命令模式：通常包含多个角色（命令、具体命令、调用者、接收者），结构较为复杂。
   • 函数对象：通常只需要一个包含 operator() 方法的类，结构较为简单。

3. 使用场景：

   • 命令模式：适用于需要对请求进行排队、记录日志、支持撤销和重做等操作的场景。
   • 函数对象：适用于需要将行为封装到对象中，并像函数一样调用的场景。

命令模式和函数对象在C++中都可以用于封装行为，但它们在设计意图和使用场景上有所不同。命令模式主要用于将请求封装成对象，从而支持请求的排队、记录日志、撤销和重做等操作；而函数对象主要用于将行为封装到对象中，使得对象可以像函数一样被调用，强调行为的灵活性和可组合性。