设计模式 | 状态模式

状态模式（State Pattern）是行为型设计模式中的状态管理大师，它允许对象在其内部状态改变时改变其行为，使对象看起来像是修改了它的类。这种模式将状态抽象为独立的类，并通过委托将行为转移给当前状态对象，实现了状态与行为的优雅解耦。本文将深入探索状态模式的核心思想、实现技巧以及在C++中的高效实践。

---

为什么需要状态模式？

在软件开发中，对象行为常随状态变化：

• 电梯的运行状态（停止、上升、下降）

• TCP连接状态（建立、监听、关闭）

• 订单生命周期（创建、支付、发货、完成）

• 游戏角色状态（站立、奔跑、跳跃、攻击）

• 工作流引擎的状态转换

硬编码状态处理会导致：
条件爆炸：复杂的if-else或switch-case语句
维护困难：添加新状态需修改现有代码
紧耦合：状态转换逻辑与业务逻辑混杂
可读性差：状态处理逻辑分散在多个方法

状态模式通过将状态对象化解决了这些问题。

---

状态模式的核心概念

模式结构解析

[上下文] ↔ [状态接口] 
              ▲
              |
        [具体状态A] [具体状态B]

关键角色定义

1. 上下文（Context）

   • 定义客户端接口

   • 维护当前状态对象

   • 将请求委托给状态对象处理

2. 状态接口（State）

   • 定义状态行为接口

   • 封装与上下文相关的状态行为

3. 具体状态（Concrete State）

   • 实现状态接口

   • 处理特定状态的行为

   • 管理状态转换逻辑

---

C++实现：智能电梯控制系统

实现支持多种运行状态和故障处理的电梯系统：

#include 
#include 
#include 
#include 

---

状态模式的五大优势

1. 消除条件分支

   // 无需switch-case
   void handleRequest() {
       currentState_->handleRequest(); // 委托给状态对象
   }

2. 状态对象化

   class IdleState : public State {
       void handleAction() override {
           // 空闲状态特定行为
       }
   };

3. 单一职责原则

   // 每个状态类只关注特定状态的行为
   class MovingState : public State { /* 移动相关行为 */ };

4. 开放封闭原则

   // 添加新状态不影响现有代码
   class MaintenanceState : public State { /* 新增维护状态 */ };

5. 状态转换显式化

   void changeState(State* newState) {
       // 明确的状态转换点
   }

---

状态模式的高级应用

1. 状态表驱动

class StateTable {
public:
    struct Transition {
        State* nextState;
        void (State::*action)(Context&);
    };
    
    void addTransition(State* from, Event event, Transition trans) {
        transitions_[from][event] = trans;
    }
    
    void handleEvent(Context& context, Event event) {
        auto& stateTrans = transitions_[context.currentState()];
        if (stateTrans.find(event) != stateTrans.end()) {
            auto& trans = stateTrans[event];
            (trans.action)(context); // 执行状态动作
            context.changeState(trans.nextState); // 转换状态
        }
    }

private:
    std::map> transitions_;
};

2. 分层状态机

class HierarchicalState : public State {
public:
    void handleEvent(Context& context, Event event) override {
        if (currentSubState_ && currentSubState_->handleEvent(context, event)) {
            return;
        }
        // 当前状态处理
        State::handleEvent(context, event);
    }
    
    void setSubState(State* substate) {
        currentSubState_ = substate;
    }

private:
    State* currentSubState_ = nullptr;
};

class RunningState : public HierarchicalState {
    // 包含子状态：加速、匀速、减速
};

3. 状态历史管理

class StateHistory {
public:
    void push(State* state) {
        history_.push(state);
    }
    
    State* pop() {
        if (history_.empty()) return nullptr;
        auto state = history_.top();
        history_.pop();
        return state;
    }
    
    void clear() {
        while (!history_.empty()) history_.pop();
    }

private:
    std::stack history_;
};

class Context {
    void returnToPreviousState() {
        if (auto prevState = history_.pop()) {
            setState(prevState);
        }
    }
};

---

状态模式的应用场景

1. 网络协议实现

class TCPConnection {
public:
    void open() {
        state_->open(this);
    }
    
    void transmit(const std::string& data) {
        state_->transmit(this, data);
    }
    
    void close() {
        state_->close(this);
    }

private:
    TCPState* state_;
};

class TCPEstablished : public TCPState {
    void transmit(TCPConnection* conn, const std::string& data) override {
        // 传输数据
    }
    
    void close(TCPConnection* conn) override {
        // 切换到关闭状态
        conn->changeState(new TCPClosed());
    }
};

2. 游戏角色状态

class GameCharacter {
public:
    void update() {
        state_->update(this);
    }
    
    void handleInput(Input input) {
        state_->handleInput(this, input);
    }

private:
    CharacterState* state_;
};

class JumpingState : public CharacterState {
    void update(GameCharacter* character) override {
        // 跳跃物理逻辑
        if (character->isOnGround()) {
            character->changeState(new StandingState());
        }
    }
    
    void handleInput(GameCharacter* character, Input input) override {
        if (input == Input::ATTACK) {
            character->changeState(new JumpAttackState());
        }
    }
};

3. 订单处理系统

class Order {
public:
    void process() {
        state_->process(this);
    }
    
    void cancel() {
        state_->cancel(this);
    }
    
    void ship() {
        state_->ship(this);
    }

private:
    OrderState* state_;
};

class ShippedState : public OrderState {
    void process(Order* order) override {
        // 已发货订单处理逻辑
    }
    
    void cancel(Order* order) override {
        // 已发货订单不能取消
        throw std::runtime_error("已发货订单不能取消");
    }
};

---

状态模式与其他模式的关系

模式	关系	区别
策略	结构相似，意图不同	策略模式选择算法，状态模式管理状态转换
命令	都可封装行为	命令封装操作，状态封装状态相关行为
享元	共享状态对象	享元共享对象，状态模式管理状态转换
单例	状态对象可共享	单例确保唯一实例，状态模式管理状态

组合使用示例：

// 状态模式 + 享元模式
class StateFactory {
public:
    State* getState(StateType type) {
        if (states_.find(type) == states_.end()) {
            states_[type] = createState(type);
        }
        return states_[type];
    }

private:
    std::map states_;
};

// 上下文使用
context->setState(factory.getState(StateType::IDLE));

---

状态模式的挑战与解决方案

挑战	解决方案
状态类膨胀	使用表驱动状态机
状态转换复杂	引入状态管理中间层
共享状态数据	使用上下文存储共享数据
性能开销	状态对象复用（享元模式）

表驱动状态机示例：

class StateMachine {
public:
    void handleEvent(Event event) {
        auto& actions = transitions_[currentState_];
        if (actions.find(event) != actions.end()) {
            actions[event](this); // 执行动作
        }
    }
    
    void addTransition(State state, Event event, Action action, State nextState) {
        transitions_[state][event] = [=](StateMachine* sm) {
            action(sm); // 执行动作
            sm->currentState_ = nextState; // 状态转换
        };
    }

private:
    State currentState_;
    std::map>> transitions_;
};

---

总结

状态模式是管理复杂状态转换的终极工具，它通过：

• 状态封装：每个状态成为独立类

• 行为委托：上下文将行为委托给当前状态

• 显式转换：清晰的状态转换逻辑

• 解耦设计：分离状态与行为

适用场景：

• 对象行为随状态改变

• 存在大量条件状态判断

• 状态转换逻辑复杂

• 需要清晰的状态生命周期管理

"状态模式不是简单的状态切换，而是将状态提升为一等公民。它是复杂行为管理的优雅范式。" — 设计模式实践者