C++ 状态模式详解

Cuit小唐2025-05-13 10:45

状态模式（State Pattern）是一种行为设计模式，它允许一个对象在内部状态改变时改变其行为 ，使对象看起来像是改变了其类。

核心概念

设计原则

状态模式遵循以下设计原则：

  1. 单一职责原则：将状态相关行为分离到不同类中

  2. 开闭原则：可以新增状态而不修改现有代码

  3. 封装性：状态转换逻辑封装在状态类中

主要优点

  1. 清晰状态转换：将状态转换逻辑组织化

  2. 减少条件语句：消除庞大的条件状态判断

  3. 可扩展性：容易添加新状态和转换

  4. 行为局部化：状态特定行为集中在对应状态类中

模式结构

主要组件

  1. Context（上下文）

    • 维护当前状态的引用

    • 将状态相关请求委托给当前状态对象

  2. State（状态接口）

    • 定义状态接口

    • 封装与Context特定状态相关的行为

  3. ConcreteState（具体状态）

    • 实现状态接口

    • 每个子类实现与Context状态相关的行为

完整代码示例

复制代码 
#include <iostream>
#include <memory>
#include <string>

// 前置声明
class State;

// ==================== 上下文类 ====================
class Player {
    std::unique_ptr<State> state_;
    std::string name_;
    
public:
    explicit Player(const std::string& name);
    
    void setState(std::unique_ptr<State> state);
    std::string getName() const;
    
    // 玩家行为
    void play();
    void pause();
    void stop();
    void lock();
    void unlock();
};

// ==================== 状态接口 ====================
class State {
public:
    virtual ~State() = default;
    virtual void play(Player* player) = 0;
    virtual void pause(Player* player) = 0;
    virtual void stop(Player* player) = 0;
    virtual void lock(Player* player) = 0;
    virtual void unlock(Player* player) = 0;
    
protected:
    void changeState(Player* player, std::unique_ptr<State> state) {
        player->setState(std::move(state));
    }
};

// ==================== 具体状态 ====================
class ReadyState : public State {
public:
    void play(Player* player) override;
    void pause(Player* player) override { /* 无效操作 */ }
    void stop(Player* player) override { /* 无效操作 */ }
    void lock(Player* player) override;
    void unlock(Player* player) override { /* 已在解锁状态 */ }
};

class PlayingState : public State {
public:
    void play(Player* player) override { /* 已在播放状态 */ }
    void pause(Player* player) override;
    void stop(Player* player) override;
    void lock(Player* player) override;
    void unlock(Player* player) override { /* 无效操作 */ }
};

class PausedState : public State {
public:
    void play(Player* player) override;
    void pause(Player* player) override { /* 已在暂停状态 */ }
    void stop(Player* player) override;
    void lock(Player* player) override;
    void unlock(Player* player) override { /* 无效操作 */ }
};

class LockedState : public State {
public:
    void play(Player* player) override { /* 锁定状态下不能播放 */ }
    void pause(Player* player) override { /* 锁定状态下不能暂停 */ }
    void stop(Player* player) override { /* 锁定状态下不能停止 */ }
    void lock(Player* player) override { /* 已在锁定状态 */ }
    void unlock(Player* player) override;
};

// ==================== 上下文方法实现 ====================
Player::Player(const std::string& name) : name_(name) {
    state_ = std::make_unique<ReadyState>();
}

void Player::setState(std::unique_ptr<State> state) {
    state_ = std::move(state);
}

std::string Player::getName() const {
    return name_;
}

void Player::play() {
    state_->play(this);
}

void Player::pause() {
    state_->pause(this);
}

void Player::stop() {
    state_->stop(this);
}

void Player::lock() {
    state_->lock(this);
}

void Player::unlock() {
    state_->unlock(this);
}

// ==================== 具体状态方法实现 ====================
void ReadyState::play(Player* player) {
    std::cout << player->getName() << ": 开始播放" << std::endl;
    changeState(player, std::make_unique<PlayingState>());
}

void ReadyState::lock(Player* player) {
    std::cout << player->getName() << ": 锁定播放器" << std::endl;
    changeState(player, std::make_unique<LockedState>());
}

void PlayingState::pause(Player* player) {
    std::cout << player->getName() << ": 暂停播放" << std::endl;
    changeState(player, std::make_unique<PausedState>());
}

void PlayingState::stop(Player* player) {
    std::cout << player->getName() << ": 停止播放" << std::endl;
    changeState(player, std::make_unique<ReadyState>());
}

void PlayingState::lock(Player* player) {
    std::cout << player->getName() << ": 锁定播放器" << std::endl;
    changeState(player, std::make_unique<LockedState>());
}

void PausedState::play(Player* player) {
    std::cout << player->getName() << ": 恢复播放" << std::endl;
    changeState(player, std::make_unique<PlayingState>());
}

void PausedState::stop(Player* player) {
    std::cout << player->getName() << ": 停止播放" << std::endl;
    changeState(player, std::make_unique<ReadyState>());
}

void PausedState::lock(Player* player) {
    std::cout << player->getName() << ": 锁定播放器" << std::endl;
    changeState(player, std::make_unique<LockedState>());
}

void LockedState::unlock(Player* player) {
    std::cout << player->getName() << ": 解锁播放器" << std::endl;
    changeState(player, std::make_unique<ReadyState>());
}

// ==================== 客户端代码 ====================
int main() {
    std::cout << "=== 状态模式演示: 音乐播放器 ===" << std::endl;
    
    Player player("我的播放器");
    
    // 正常流程
    player.play();
    player.pause();
    player.play();
    player.stop();
    
    // 锁定测试
    std::cout << "\n测试锁定功能:" << std::endl;
    player.play();
    player.lock();
    player.play();  // 应该无效
    player.unlock();
    player.play();
    
    // 无效操作测试
    std::cout << "\n测试无效操作:" << std::endl;
    player.stop();
    player.stop();  // 应该无效
    player.pause(); // 应该无效
    
    return 0;
}

模式变体

1. 状态表驱动

复制代码 
class StateMachine {
    std::unordered_map<std::string, 
        std::unordered_map<std::string, 
            std::function<void()>>> transitions_;
    std::string currentState_;
    
public:
    void addTransition(const std::string& from, const std::string& event, 
                      const std::string& to, std::function<void()> action) {
        transitions_[from][event] = [this, to, action] {
            action();
            currentState_ = to;
        };
    }
    
    void handleEvent(const std::string& event) {
        auto& stateTransitions = transitions_[currentState_];
        if (stateTransitions.find(event) != stateTransitions.end()) {
            stateTransitions[event]();
        }
    }
};

2. 共享状态对象

复制代码 
class SharedState : public State {
    // 可以共享的状态数据
};

class ConcreteStateA : public SharedState {
    // 实现特定行为
};

// 使用时可以共享同一个状态实例
auto sharedState = std::make_shared<ConcreteStateA>();
context1.setState(sharedState);
context2.setState(sharedState);

实际应用场景

  1. 工作流引擎：如订单状态流转

  2. 游戏开发：角色行为状态管理

  3. UI系统：控件不同状态下的行为

  4. 网络协议：协议状态机实现

  5. 硬件控制：设备状态管理

相关推荐
小羊在睡觉2 分钟前
golang定时器
开发语言·后端·golang
CoderCodingNo20 分钟前
【GESP】C++四级真题 luogu-B4068 [GESP202412 四级] Recamán
开发语言·c++·算法
一个不知名程序员www22 分钟前
算法学习入门---双指针（C++)
c++·算法
Maple_land36 分钟前
常见Linux环境变量深度解析
linux·运维·服务器·c++·centos
Larry_Yanan44 分钟前
QML学习笔记（四十四）QML与C++交互：对QML对象设置objectName
开发语言·c++·笔记·qt·学习·ui·交互
百锦再1 小时前
对前后端分离与前后端不分离（通常指服务端渲染）的架构进行全方位的对比分析
java·开发语言·python·架构·eclipse·php·maven
Want5951 小时前
C/C++大雪纷飞①
c语言·开发语言·c++
Mr_WangAndy1 小时前
C++设计模式_行为型模式_策略模式Strategy
c++·设计模式·策略模式·依赖倒置原则
LoveXming2 小时前
Chapter11—适配器模式
c++·设计模式·适配器模式·开闭原则
Benny_Tang2 小时前
题解：P7989 [USACO21DEC] Bracelet Crossings G
c++·算法
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南082025软件测试面试八股文（含答案+文档）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10Labelme从安装到标注：零基础完整指南