C++ 设计模式精讲：状态模式的原理、实现与应用场景

在复杂的软件系统中，对象的状态经常会发生变化，并且在不同的状态下，对象的行为也会有所不同。如果直接使用大量的 if-else 或 switch-case 语句来处理这些状态和行为，代码会变得非常臃肿、难以维护和扩展。今天我们就来聊聊如何使用状态模式，优雅地解决这个问题，提升 C++ 代码的可读性和可维护性。

问题场景：订单状态流转的挑战

想象一下电商平台的订单系统。一个订单可能经历“待支付”、“已支付”、“待发货”、“已发货”、“已完成”、“已取消”等多种状态。每个状态下，订单可以执行的操作也不同，比如“待支付”状态可以“支付”或“取消”，“已发货”状态可以“确认收货”。如果用传统的条件判断，代码会变成这样：

class Order {
public:
  enum class State {
    PENDING_PAYMENT,
    PAID,
    SHIPPED,
    COMPLETED,
    CANCELLED
  };

  void processOrder(State newState) {
    currentState = newState;

    // 大量的 if-else 或 switch-case 语句
    if (currentState == State::PENDING_PAYMENT) {
      // ...
    } else if (currentState == State::PAID) {
      // ...
    } else if (currentState == State::SHIPPED) {
      // ...
    }
  }

private:
  State currentState = State::PENDING_PAYMENT;
};

随着状态的增加和业务逻辑的复杂化，这段代码会迅速膨胀，变得难以阅读和修改。这就像早期的 Nginx 配置，所有逻辑都堆积在一个配置文件里，导致维护困难。类似地，不恰当的设计模式也可能导致系统维护成本增高，在高并发场景下甚至可能出现性能瓶颈。

状态模式的核心思想

状态模式（State Pattern） 允许一个对象在其内部状态改变时改变它的行为。对象看起来好像修改了它的类。其核心思想是将状态封装成独立的类，并将状态转换的逻辑委托给这些状态类处理，从而避免大量的条件判断语句。状态模式符合“开闭原则”，易于扩展新的状态。

状态模式的结构

状态模式主要包含以下几个角色：

• Context（环境类）： 维护一个 ConcreteState 子类的实例，这个实例定义当前状态。
• State（抽象状态类）： 定义一个接口，用以封装与 Context 的一个特定状态相关的行为。
• ConcreteState（具体状态类）： 实现了 State 接口，实现与 Context 的一个状态相关的行为。

C++ 代码实现：订单状态模式

下面是用 C++ 实现订单状态模式的示例代码：

#include <iostream>
#include <string>

// 抽象状态类
class OrderState {
public:
  virtual void handlePayment() = 0; // 处理支付
  virtual void handleShipment() = 0; // 处理发货
  virtual void handleCompletion() = 0; // 处理完成
  virtual void handleCancellation() = 0; // 处理取消
  virtual std::string getStateName() = 0; // 获取状态名称
  virtual ~OrderState() = default;
};

// 具体状态类：待支付状态
class PendingPaymentState : public OrderState {
public:
  void handlePayment() override {
    std::cout << "Payment received. Order is now Paid.\n";
  }

  void handleShipment() override {
    std::cout << "Cannot ship. Order is pending payment.\n";
  }

  void handleCompletion() override {
    std::cout << "Cannot complete. Order is pending payment.\n";
  }

  void handleCancellation() override {
    std::cout << "Order cancelled before payment.\n";
  }

  std::string getStateName() override { return "Pending Payment"; }
};

// 具体状态类：已支付状态
class PaidState : public OrderState {
public:
  void handlePayment() override {
    std::cout << "Order already paid.\n";
  }

  void handleShipment() override {
    std::cout << "Shipping order.\n";
  }

  void handleCompletion() override {
    std::cout << "Cannot complete. Order is being shipped.\n";
  }

  void handleCancellation() override {
    std::cout << "Cannot cancel. Order is already paid.\n";
  }

  std::string getStateName() override { return "Paid"; }
};

// 环境类：订单
class Order {
public:
  Order() : state(new PendingPaymentState()) {}

  void setState(OrderState* newState) {
    delete state; // 释放旧状态
    state = newState;
  }

  void processPayment() {
    std::cout << "Processing payment in " << state->getStateName() << " state.\n";
    state->handlePayment();
    if (state->getStateName() == "Pending Payment") {
        setState(new PaidState());
    }
  }

  void processShipment() {
    std::cout << "Processing shipment in " << state->getStateName() << " state.\n";
    state->handleShipment();
  }

  void processCompletion() {
    std::cout << "Processing completion in " << state->getStateName() << " state.\n";
    state->handleCompletion();
  }

  void processCancellation() {
    std::cout << "Processing cancellation in " << state->getStateName() << " state.\n";
    state->handleCancellation();
  }

  std::string getCurrentStateName() {
      return state->getStateName();
  }

  ~Order() {
    delete state; // 释放状态
  }

private:
  OrderState* state; // 当前状态
};

int main() {
  Order order;
  order.processPayment();
  order.processShipment();
  order.processCompletion();

  return 0;
}

在这个例子中，Order 类是环境类，OrderState 是抽象状态类，PendingPaymentState 和 PaidState 是具体状态类。每个状态类负责处理特定状态下的行为。通过 setState 方法，Order 对象可以在不同的状态之间切换。

实战避坑：状态转换的控制

在使用状态模式时，需要特别注意状态转换的控制。一种常见的错误是在状态类中直接改变 Context 的状态，这会导致状态转换的逻辑分散在各个状态类中，不利于维护。正确的做法是由 Context 类来控制状态的转换，状态类只负责处理特定状态下的行为。

此外，还需要考虑线程安全问题。在高并发环境下，需要对状态的访问和修改进行同步，以避免数据竞争。

在实际项目中，可以结合工厂模式和单例模式来创建和管理状态对象，例如使用工厂模式创建具体的 ConcreteState 对象，并使用单例模式保证每个状态只有一个实例。 这能有效减少内存占用，提升性能，尤其是在高流量场景下，例如处理大量用户请求的 Web 服务器，如使用宝塔面板管理的 Nginx 服务器，需要考虑到并发连接数和资源占用。

总结

状态模式是一种强大的设计模式，可以有效地解决对象状态转换的问题，提高代码的可读性、可维护性和可扩展性。希望本文能够帮助你更好地理解和应用状态模式，并在实际项目中避免常见的陷阱。在面对复杂的业务逻辑时，合理运用设计模式，能让你的代码更加健壮和优雅。