1. 状态模式的核心概念解析状态模式是GoF 23种设计模式中行为型模式的一种它允许对象在内部状态改变时改变其行为使对象看起来像是修改了它的类。在C中实现状态模式能够优雅地处理复杂的状态转换逻辑特别适合游戏开发、工作流引擎等场景。状态模式的核心在于将特定状态相关的行为封装到独立的类中并通过委托的方式让主对象在不同状态下表现出不同行为。这种方式避免了庞大的条件判断语句if-else或switch-case使得状态转换更加清晰可维护。关键提示当你的代码中出现大量与对象状态相关的条件判断时就是考虑使用状态模式的绝佳时机。2. 状态模式的典型结构实现2.1 基础类结构设计在C中实现状态模式通常包含以下几个关键组件Context上下文定义客户端感兴趣的接口维护一个ConcreteState子类的实例State抽象状态定义一个接口以封装与Context的一个特定状态相关的行为ConcreteState具体状态实现与Context的一个状态相关的行为// 抽象状态类 class State { public: virtual void handle(Context* context) 0; virtual ~State() default; }; // 具体状态A class ConcreteStateA : public State { public: void handle(Context* context) override; }; // 具体状态B class ConcreteStateB : public State { public: void handle(Context* context) override; }; // 上下文类 class Context { private: State* state; public: explicit Context(State* state) : state(state) {} void request() { state-handle(this); } void changeState(State* state) { this-state state; } };2.2 状态转换的实现机制状态转换可以通过两种主要方式实现由Context决定状态转换Context持有所有状态实例根据条件决定转换由具体状态决定转换每个具体状态知道下一个应该进入的状态第一种方式更集中化适合状态转换逻辑相对固定的场景第二种方式更分散适合状态转换逻辑与特定状态紧密相关的场景。3. 状态模式在C中的高级应用3.1 使用智能指针管理状态生命周期在现代C中我们可以利用智能指针来更好地管理状态的生存周期class Context { private: std::unique_ptrState state; public: explicit Context(std::unique_ptrState state) : state(std::move(state)) {} void changeState(std::unique_ptrState newState) { state std::move(newState); } // 其他成员函数... };这种方式避免了手动内存管理更符合RAII原则减少了内存泄漏的风险。3.2 状态模式的线程安全实现在多线程环境下使用状态模式需要特别注意线程安全问题。以下是几种常见的线程安全策略互斥锁保护在状态转换和状态操作时加锁无锁设计使用原子操作或不可变状态线程局部存储每个线程维护自己的状态实例#include mutex class ThreadSafeContext { private: std::unique_ptrState state; mutable std::mutex mtx; public: explicit ThreadSafeContext(std::unique_ptrState state) : state(std::move(state)) {} void changeState(std::unique_ptrState newState) { std::lock_guardstd::mutex lock(mtx); state std::move(newState); } void request() { std::lock_guardstd::mutex lock(mtx); state-handle(this); } };4. 状态模式在实际项目中的应用案例4.1 游戏角色状态管理在游戏开发中角色通常有多种状态站立、行走、奔跑、跳跃、攻击等使用状态模式可以优雅地管理这些状态// 游戏角色状态基类 class CharacterState { public: virtual void enter(Character* character) 0; virtual void update(Character* character, float deltaTime) 0; virtual void exit(Character* character) 0; virtual ~CharacterState() default; }; // 站立状态 class StandingState : public CharacterState { public: void enter(Character* character) override { character-setAnimation(standing); } void update(Character* character, float deltaTime) override { if (character-isMoving()) { character-changeState(std::make_uniqueWalkingState()); } } void exit(Character* character) override { // 清理站立状态相关资源 } }; // 角色类 class Character { private: std::unique_ptrCharacterState currentState; public: void changeState(std::unique_ptrCharacterState newState) { if (currentState) { currentState-exit(this); } currentState std::move(newState); currentState-enter(this); } void update(float deltaTime) { currentState-update(this, deltaTime); } };4.2 网络连接状态管理网络通信中的连接状态断开、连接中、已连接、重连等也适合使用状态模式class ConnectionState { public: virtual void connect(Connection* conn) 0; virtual void disconnect(Connection* conn) 0; virtual void sendData(Connection* conn, const std::string data) 0; virtual ~ConnectionState() default; }; class DisconnectedState : public ConnectionState { public: void connect(Connection* conn) override { // 实现连接逻辑 conn-changeState(std::make_uniqueConnectingState()); } void disconnect(Connection* conn) override { // 已经是断开状态无需操作 } void sendData(Connection* conn, const std::string data) override { throw std::runtime_error(Cannot send data in disconnected state); } }; // 其他状态实现类似...5. 状态模式的优化与变体5.1 使用状态表替代状态类对于状态数量较多但行为相似的情况可以使用状态表来简化实现class StateMachine { private: std::unordered_mapint, std::functionvoid(StateMachine*) stateTable; int currentState; public: StateMachine() { // 初始化状态表 stateTable[0] [](StateMachine* sm) { /* 状态0行为 */ }; stateTable[1] [](StateMachine* sm) { /* 状态1行为 */ }; // ... } void update() { stateTable[currentState](this); } void changeState(int newState) { currentState newState; } };5.2 状态模式的性能优化状态模式可能引入的性能问题及解决方案状态对象创建开销使用对象池或享元模式共享状态实例频繁状态转换开销批量处理状态转换或使用惰性转换虚函数调用开销对于性能关键路径考虑CRTP模式消除虚函数调用// 使用CRTP优化状态模式 template typename Derived class StateBase { public: void handle(Context* context) { static_castDerived*(this)-handleImpl(context); } }; class ConcreteStateA : public StateBaseConcreteStateA { public: void handleImpl(Context* context) { // 具体实现 } };6. 状态模式与其他设计模式的结合6.1 状态模式与策略模式的比较虽然状态模式和策略模式在结构上相似但它们的意图不同特性状态模式策略模式目的封装状态相关的行为封装可互换的算法状态转换通常由状态类自身控制通常由客户端控制对象行为随内部状态改变而改变行为在运行时选择后固定典型应用游戏角色状态、工作流引擎排序算法、压缩算法6.2 状态模式与观察者模式的结合将观察者模式与状态模式结合可以实现状态变化的通知机制class ObservableState : public State { private: std::vectorstd::functionvoid(State*) observers; public: void addObserver(std::functionvoid(State*) observer) { observers.push_back(observer); } void notify() { for (auto observer : observers) { observer(this); } } }; class ConcreteObservableState : public ObservableState { public: void handle(Context* context) override { // 状态处理逻辑 notify(); // 通知观察者状态变化 } };7. 状态模式的最佳实践与常见陷阱7.1 状态模式实现的最佳实践保持状态类无状态尽可能使具体状态类成为无状态的单例明确定义状态转换清晰地文档化所有可能的状态转换路径考虑状态持久化为需要持久化的场景提供序列化/反序列化支持合理划分状态粒度避免状态过多导致系统复杂也避免状态过少失去意义7.2 常见陷阱与解决方案循环状态转换A→B→C→A可能导致无限循环解决方案引入转换条件或限制转换频率状态爆炸状态类数量过多难以维护解决方案使用状态表或参数化状态共享状态数据多个状态需要访问相同数据解决方案将共享数据放在Context中测试困难状态转换路径复杂难以测试解决方案为每个状态编写独立测试再测试转换逻辑// 示例防止循环状态转换 class SafeContext { private: State* currentState; State* previousState; int transitionCount 0; static constexpr int MAX_TRANSITIONS 10; public: void changeState(State* newState) { if (transitionCount MAX_TRANSITIONS) { throw std::runtime_error(Possible infinite state loop detected); } previousState currentState; currentState newState; transitionCount; } void resetTransitionCount() { transitionCount 0; } };8. C状态模式的现代实现技术8.1 使用std::variant实现类型安全状态C17引入的std::variant可以用来实现类型安全的状态模式#include variant struct StateA { void handle() { /* ... */ } }; struct StateB { void handle() { /* ... */ } }; using State std::variantStateA, StateB; class ModernContext { private: State state; public: explicit ModernContext(State initialState) : state(initialState) {} void request() { std::visit([](auto s) { s.handle(); }, state); } template typename NewState void changeState(NewState newState) { state newState; } };8.2 使用函数式风格实现轻量级状态机对于简单场景可以使用函数指针或std::function实现轻量级状态机class LightweightStateMachine { private: std::functionvoid(LightweightStateMachine*) currentState; public: void setState(std::functionvoid(LightweightStateMachine*) state) { currentState state; } void update() { if (currentState) { currentState(this); } } }; // 使用示例 LightweightStateMachine sm; sm.setState([](LightweightStateMachine* sm) { // 状态行为实现 });9. 状态模式在大型项目中的架构考虑9.1 状态模式的模块化设计在大型项目中实现状态模式时应考虑以下架构原则状态接口模块定义核心状态接口和上下文基类状态实现模块按功能或领域组织具体状态实现状态工厂模块集中管理状态对象的创建状态转换规则模块单独维护状态转换逻辑9.2 状态模式与依赖注入的结合使用依赖注入框架管理状态依赖关系// 使用Boost.DI示例 auto injector boost::di::make_injector( boost::di::bindState.toConcreteStateA(), boost::di::bindContext.toMyContext() ); auto context injector.createstd::unique_ptrContext();9.3 状态模式与事件驱动架构将状态模式与事件驱动架构结合实现响应式状态管理class EventDrivenStateMachine { private: State* currentState; std::queuestd::unique_ptrEvent eventQueue; public: void postEvent(std::unique_ptrEvent event) { eventQueue.push(std::move(event)); } void processEvents() { while (!eventQueue.empty()) { auto event std::move(eventQueue.front()); eventQueue.pop(); currentState-handleEvent(this, event.get()); } } };10. 状态模式的测试策略10.1 单元测试状态行为为每个具体状态编写独立的单元测试TEST(StandingStateTest, ShouldTransitionToWalkingWhenMoving) { Character character; auto state std::make_uniqueStandingState(); MockCharacter mockCharacter; EXPECT_CALL(mockCharacter, isMoving()).WillOnce(Return(true)); EXPECT_CALL(mockCharacter, changeState(_)); state-update(mockCharacter, 0.0f); }10.2 集成测试状态转换测试状态之间的转换逻辑TEST(StateTransitionTest, ShouldFollowCorrectStateSequence) { Context ctx(std::make_uniqueStateA()); ctx.request(); // StateA - StateB EXPECT_EQ(typeid(*ctx.getState()), typeid(StateB)); ctx.request(); // StateB - StateC EXPECT_EQ(typeid(*ctx.getState()), typeid(StateC)); }10.3 使用状态图验证设计可以使用状态图工具验证状态转换的正确性生成状态图根据代码生成状态转换图验证完整性检查是否有不可达状态或缺失转换模拟执行自动生成测试用例覆盖所有转换路径11. 状态模式在不同领域的变体应用11.1 分层状态机对于复杂状态逻辑可以使用分层状态机class HierarchicalState { protected: HierarchicalState* parent nullptr; public: virtual void handle(Context* context) { if (parent) { parent-handle(context); } } void setParent(HierarchicalState* parentState) { parent parentState; } }; // 子状态可以继承父状态的行为 class SubState : public HierarchicalState { public: void handle(Context* context) override { // 先执行子状态特有行为 // ... // 然后委托给父状态 HierarchicalState::handle(context); } };11.2 并行状态机当对象需要同时处于多个独立状态时可以使用并行状态机class ParallelStateMachine { private: std::vectorstd::unique_ptrState activeStates; public: void addState(std::unique_ptrState state) { activeStates.push_back(std::move(state)); } void update() { for (auto state : activeStates) { state-handle(this); } } };11.3 历史状态某些场景需要记住并恢复之前的状态class StateWithHistory : public State { private: std::stackstd::unique_ptrState history; public: void pushState(std::unique_ptrState state) { history.push(std::move(state)); } std::unique_ptrState popState() { if (history.empty()) return nullptr; auto state std::move(history.top()); history.pop(); return state; } };12. 状态模式的性能分析与优化12.1 状态模式的内存开销分析状态模式可能引入的内存开销来源状态对象本身每个具体状态类的实例状态转换开销频繁创建/销毁状态对象虚函数表多态带来的额外开销优化策略使用单例状态如果状态无实例数据对象池管理状态实例减少状态转换频率12.2 状态模式的CPU开销分析性能热点可能出现在虚函数调用间接调用带来的分支预测失败状态转换逻辑复杂的转换条件判断状态查找在状态表中查找当前状态优化技术// 使用函数指针代替虚函数 class State { public: using Handler void(*)(Context*); Handler handler; }; // 直接调用函数指针避免虚函数开销 void StateAHandler(Context* ctx) { /* ... */ } void StateBHandler(Context* ctx) { /* ... */ } State stateA{StateAHandler}; State stateB{StateBHandler};13. 状态模式的可视化与调试13.1 状态转换日志添加详细的日志记录状态转换class LoggingContext : public Context { public: void changeState(State* newState) override { log(State change: {} - {}, typeid(*currentState).name(), typeid(*newState).name()); Context::changeState(newState); } };13.2 运行时状态检查添加运行时状态一致性检查void Context::performSafetyChecks() { if (currentState nullptr) { throw std::logic_error(Current state is null); } if (!validTransitions.contains(currentState)) { throw std::logic_error(Invalid current state); } }13.3 图形化状态监控开发图形化工具实时显示状态class StateVisualizer { public: void drawStateDiagram(const Context ctx) { // 使用图形库绘制当前状态及可能转换 } };14. 状态模式与C语言特性的深度结合14.1 使用constexpr实现编译时状态机C11/14/17引入的constexpr可以创建编译时状态机template typename T class ConstexprState { public: constexpr void handle() const { static_castconst T*(this)-handleImpl(); } }; class StateA : public ConstexprStateStateA { public: constexpr void handleImpl() const { // 编译时处理逻辑 } }; constexpr void processState() { StateA state; state.handle(); // 编译时执行 }14.2 使用模板元编程优化状态模式通过模板元编程实现零开销抽象template typename State class TemplateContext { private: State state; public: template typename Event void handle(const Event event) { state.handle(*this, event); } template typename NewState void transitionTo() { // 状态转换逻辑 } };15. 状态模式在C项目中的实际应用建议15.1 何时使用状态模式适合使用状态模式的典型场景对象的行为取决于它的状态并且必须在运行时根据状态改变行为操作中含有大量条件语句且这些条件依赖于对象的状态状态转换逻辑复杂需要清晰的组织和管理状态数量较多且预期会随时间增加15.2 何时避免状态模式可能不适合使用状态模式的情况状态非常简单且稳定条件判断足够清晰状态转换逻辑极其简单引入模式反而增加复杂度性能极其敏感的场合虚函数开销不可接受状态数量很少且不会增长15.3 状态模式的演进策略如何在现有代码中逐步引入状态模式识别状态相关代码找出与状态相关的条件判断提取状态接口定义状态基类和基本行为创建具体状态将条件分支逻辑迁移到具体状态类引入上下文类创建管理状态的上下文类逐步替换逐步用新实现替换旧的条件逻辑完善测试确保状态转换行为保持不变16. 状态模式的学习资源与进阶方向16.1 推荐学习资源书籍《设计模式可复用面向对象软件的基础》GoF经典《Head First设计模式》更易理解的讲解《C软件设计》现代C设计模式实践在线资源CppReference上的设计模式示例GitHub上的开源状态机实现各种技术博客中的状态模式案例分析工具状态图设计工具如PlantUML代码生成工具根据状态图生成C代码16.2 进阶研究方向形式化验证使用数学方法验证状态机的正确性DSL设计为特定领域设计状态机描述语言自动生成从高级描述自动生成状态模式代码分布式状态机在分布式系统中实现一致的状态管理持久化状态机支持状态的可持久化和恢复17. 状态模式在现代C中的发展趋势17.1 C20/23新特性对状态模式的影响概念(Concepts)可以更好地约束状态接口协程(Coroutines)实现异步状态机模块(Modules)更好地组织状态模式相关代码模式匹配(Pattern Matching)简化状态转换逻辑17.2 函数式编程风格的影响现代C越来越支持函数式风格这对状态模式的实现方式产生影响使用std::function和lambda替代继承不可变状态与纯函数使用高阶函数组合状态行为auto makeStateMachine(std::functionvoid() initialState) { return [currentState std::move(initialState)]() mutable { currentState(); }; }17.3 元编程与编译时状态机利用现代C的元编程能力可以在编译期完成更多状态机相关工作编译时状态转换验证生成最优化的状态处理代码静态检查状态完整性template auto... States class StaticStateMachine { // 编译时已知的状态集合 };18. 状态模式与其他技术的结合应用18.1 状态模式与AI行为树在游戏AI中状态模式可以与行为树结合class AIState : public BehaviorTree::Node { public: virtual Status update() override { // 状态特定的AI行为 return Status::Success; } }; class AIStateMachine : public BehaviorTree::Composite { private: std::mapstd::string, std::unique_ptrAIState states; AIState* currentState; public: void changeState(const std::string stateName) { currentState states[stateName].get(); } Status update() override { return currentState-update(); } };18.2 状态模式与反应式编程将状态模式与反应式编程框架如RxCpp结合class ReactiveStateMachine { private: rxcpp::subjects::subjectState* stateSubject; State* currentState; public: ReactiveStateMachine(State* initialState) : currentState(initialState) { stateSubject.get_observer().on_next(currentState); } auto getStateObservable() { return stateSubject.get_observable(); } void changeState(State* newState) { currentState newState; stateSubject.get_observer().on_next(currentState); } };19. 状态模式在特定领域的深度应用19.1 游戏开发中的状态模式进阶游戏开发中状态模式的高级应用技巧状态混合同时应用多个状态的效果如边跑边射击状态覆盖临时覆盖某些状态行为如被击中的反应状态优先级处理状态冲突的优先级系统状态参数化通过参数调整状态行为class GameCharacter { private: std::vectorstd::unique_ptrCharacterState activeStates; std::mapint, std::unique_ptrCharacterState statePriorities; public: void addState(std::unique_ptrCharacterState state, int priority) { statePriorities.emplace(priority, std::move(state)); } void update(float deltaTime) { for (auto [_, state] : statePriorities) { state-update(this, deltaTime); } } };19.2 嵌入式系统中的状态模式在资源受限的嵌入式系统中实现状态模式的技巧静态分配避免动态内存分配预先分配所有状态简化接口最小化状态接口以减少虚函数开销无继承实现使用函数指针或枚举代替继承状态压缩使用位域表示简单状态// 嵌入式友好的状态机实现 typedef void (*StateHandler)(void* context); struct EmbeddedStateMachine { StateHandler currentState; void* context; }; void stateAHandler(void* context) { /* ... */ } void stateBHandler(void* context) { /* ... */ } EmbeddedStateMachine machine; machine.currentState stateAHandler; machine.context someData;20. 状态模式的替代方案与比较20.1 状态模式与条件判断的对比对于简单场景条件判断可能比状态模式更合适标准状态模式条件判断复杂度适合复杂状态逻辑适合简单状态逻辑可维护性状态变化时只需修改对应状态类需要修改集中的条件判断块可扩展性容易添加新状态添加新状态需要修改现有条件逻辑运行时效率虚函数调用有一定开销直接条件判断效率更高代码组织状态行为分散在各个类中所有状态逻辑集中在一处20.2 状态模式与表驱动方法的对比表驱动方法是状态模式的另一种实现方式// 表驱动状态机示例 class TableDrivenStateMachine { private: struct Transition { int currentState; int event; int newState; std::functionvoid() action; }; std::vectorTransition transitionTable; int currentState; public: void addTransition(int from, int onEvent, int to, std::functionvoid() action) { transitionTable.push_back({from, onEvent, to, action}); } void handleEvent(int event) { for (const auto trans : transitionTable) { if (trans.currentState currentState trans.event event) { trans.action(); currentState trans.newState; break; } } } };选择依据状态模式状态行为复杂需要封装各自逻辑表驱动状态转换规则简单明确适合大量简单状态21. 状态模式的设计质量评估21.1 评估状态模式设计的质量标准单一职责原则每个状态类是否只关注单一状态的行为开闭原则添加新状态是否需要修改现有代码接口隔离状态接口是否精简且专注依赖倒置上下文是否依赖抽象状态而非具体实现内聚耦合状态类之间是否低耦合内部高内聚21.2 状态模式的反模式与不良设计需要避免的常见不良实践上帝状态一个状态类做了太多事情违反单一职责状态耦合状态之间直接相互引用形成复杂依赖上下文膨胀上下文类承担了太多与状态无关的责任过度设计对简单状态问题使用复杂的状态模式状态泄漏状态类隐式依赖全局变量或外部资源// 不良设计示例上帝状态 class BadState : public State { public: void handle(Context* context) override { // 处理状态A逻辑 // ... // 处理状态B逻辑 // ... // 处理状态C逻辑 // ... } }; // 应该拆分为多个专门的状态类22. 状态模式的调试与性能分析技巧22.1 状态模式的调试技巧状态追踪记录完整的状态转换路径断点策略在状态转换点设置条件断点可视化工具使用图形工具显示当前状态一致性检查验证状态转换的前置后置条件单元测试为每个状态转换编写测试用例22.2 状态模式的性能分析工具Profiler工具分析虚函数调用开销Cache分析检查状态对象的内存访问模式分支预测分析评估状态转换对分支预测的影响内存分配追踪监控状态对象创建销毁频率时间测量测量关键状态处理函数的执行时间// 简单的性能测量装饰器 template typename State class ProfiledState : public State { public: void handle(Context* context) override { auto start std::chrono::high_resolution_clock::now(); State::handle(context); auto end std::chrono::high_resolution_clock::now(); std::cout State handling took: std::chrono::duration_caststd::chrono::microseconds(end - start).count() μs\n; } };23. 状态模式的可测试性设计23.1 设计可测试的状态模式提高状态模式可测试性的技巧依赖注入通过注入模拟状态进行测试接口分离将状态依赖分解为最小接口记录与回放记录状态转换序列用于测试验证确定性设计确保状态行为不依赖不可控因素测试钩子添加专门用于测试的观察点class TestableContext : public Context { public: // 暴露内部状态用于测试 State* getCurrentState() const { return currentState; } // 添加测试观察点 std::functionvoid(State*, State*) onStateChange; protected: void changeState(State* newState) override { if (onStateChange) { onStateChange(currentState, newState); } Context::changeState(newState); } };23.2 状态模式的测试策略单元测试独立测试每个状态的行为集成测试测试状态与上下文的交互状态转换测试验证所有可能的转换路径异常测试测试非法状态转换的处理性能测试评估状态转换的开销TEST(StateTransitionTest, IllegalTransitionShouldThrow) { TestableContext ctx(new StateA()); ctx.onStateChange [](State* oldState, State* newState) { if (dynamic_castStateA*(oldState) dynamic_castStateC*(newState)) { throw std::logic_error(Illegal transition from A to C); } }; EXPECT_THROW(ctx.changeState(new StateC()), std::logic_error); }24. 状态模式在C中的未来展望24.1 反射与状态模式C未来的反射特性可能对状态模式产生影响自动状态发现通过反射枚举所有可用状态动态状态加载根据名称动态创建状态实例序列化简化自动序列化/反序列化状态调试增强运行时获取状态类型信息// 假设的未来C反射示例 void loadStateByName(Context ctx, std::string_view name) { auto stateType reflexpr(name); // 假设的反射操作 ctx.changeState(stateType.construct()); }24.2 模式匹配的深度集成C23引入的模式匹配可能改变状态模式的实现方式// 假设的未来C模式匹配示例 void handleState(Context ctx) { inspect (ctx.currentState()) { is StateA { /* 处理状态A */ } is StateB { /* 处理状态B */ } is StateC { /* 处理状态C */ } } }24.3 协程与异步状态机协程为异步状态机提供新的实现可能taskvoid asyncStateMachine() { State current State::Initial; while (true) { switch (current) { case State::Initial: co_await initialize(); current State::Processing; break; case State::Processing: if (co_await processData()) { current State::Done; } break; case State::Done: co_return; } } }25. 状态模式的跨平台与跨语言考虑25.1 跨平台状态模式设计设计可移植的状态模式需要考虑平台特定行为将平台相关代码隔离到特定状态抽象接口设计状态接口不依赖平台特定类型内存模型差异考虑不同平台的内存对齐和访问线程安全策略适应不同平台的同步原语class PlatformIndependentState { public: virtual void handle() 0; protected: // 平台无关的工具方法 void log(const std::string message) { // 使用跨平台日志接口 } }; // 平台特定状态通过继承实现 class WindowsSpecificState : public PlatformIndependentState { void handle() override { // Windows特定实现 } };25.2 状态模式与其他语言的互操作在C中设计与其他语言交互的状态模式C接口封装为状态机提供纯C接口SWIG绑定生成其他语言能调用的包装消息传递通过消息队列与外部系统通信FFI考虑注意跨语言调用的类型转换// C接口示例 extern C { struct CStateMachine; CStateMachine* createStateMachine(); void processEvent(CStateMachine