有限状态机通常用来描述一个对象在其生命周期中的状态变化，以及对外界的刺激(条件改变)做出响应进而进入下一个状态，最经典就是TCP状态转移。

有限状态机 - 图1
这里要实现的是一种通用状态机，可以Send事件，每一个状态可以响应自己注册的事件，同时也可以通过自身或者事件来改变状态机的状态。

  1. Contex类：
  2.      CreateState() 接口，用于创建状态机和父状态机关系
  3.      Update() 接口，外部驱动状态机函数
  4.      SendEvent() 同步发送事件到当前状态，能发送任意数据到状态中处理
  5.      SendAsyncEvent() 异步发送事件到当前状态，能发送任意数据到状态中处理
  6. State类
  7.      virtual void start(){}      // 状态开始处理 子类实现
  8.      virtual void update(){}  // update处理 子类实现
  9.      virtual void stop(){}       // 状态结束处理 子类实现
  10.      void set_event_func();  // 设置事件处理回调函数，子类绑定

框架

框架实现如下：

context.h

  1. #ifndef _CONTEXT_H_
  2. #define _CONTEXT_H_
  3. #include "Event.h"
  4. #include <string>
  5. #include <unordered_map>
  6. #include <thread>
  8. namespace HsmState
  9. {
  10.     class State;
  11.     struct NodeState
  12.     {
  13.         NodeState& operator = (const NodeState& n)
  14.         {
  15.             _state = n._state;
  16.             _father_name = n._father_name;
  17.             return *this;
  18.         }
  19.         State* _state;
  20.         std::string _father_name;
  21.     };
  23.     class Context
  24.     {
  25.     public:
  26.         friend class State;
  28.         Context();
  30.         ~Context();
  31.         // 开始状态机
  32.         bool Start(std::string name);
  34.         // 创建一个状态
  35.         // [in] state 状态对象，在Context销毁时，内部释放state
  36.         // [in] name  状态名称，为空名称为typedname的值
  37.         // [in] father_name 父状态的名称
  38.         // [out] 返回state
  39.         State* CreateState(State* state, std::string name, std::string father_name = "");
  41.         // 更新当前状态
  42.         void Update();
  44.         // 同步事件
  45.         // 发送一个事件，提供给root状态和当前状态处理
  46.         // 如果当前状态是子状态，则还会给父状态处理
  47.         void SendEvent(EventData event_data);
  49.         // 异步事件
  50.         void SendAsyncEvent(EventData event_data);
  52.         // 获取当前状态名称
  53.         std::string GetCurStateName();
  55.     private:
  56.         // 状态切换
  57.         void TransForState(std::string name);
  59.         // 递归send
  60.         void RecursiveSend(NodeState& node_state, EventData& event_data);
  62.         std::unordered_map<std::string, NodeState> _states; // 状态列表
  63.         NodeState _cur_node_state; // 当前状态名
  64.         std::string _cur_name;
  66.         std::string _root_name;    // 根状态名
  67.     };
  68. }
  70. #endif // !STATE_H_

context.cpp

  1. #include "Context.h"
  2. #include "State.h"
  4. namespace HsmState
  5. {
  6.     Context::Context()
  7.     {
  9.     }
  11.     Context::~Context()
  12.     {
  13.         for (auto iter : _states)
  14.         {
  15.             if (iter.second._state)
  16.             {
  17.                 delete iter.second._state;
  18.                 iter.second._state = nullptr;
  19.             }
  20.         }
  21.         _states.clear();
  22.     }
  24.     // 开始状态机
  25.     bool Context::Start(std::string name)
  26.     {
  27.         std::unordered_map<std::string, NodeState>::iterator iter_map = _states.find(name);
  28.         if (iter_map != _states.end())
  29.         {
  30.             _cur_node_state = iter_map->second;
  31.             _cur_name = iter_map->first;
  32.             iter_map->second._state->start();
  33.         }
  34.         return false;
  35.     }
  37.     // 创建一个状态
  38.     // [in] state 状态对象，在Context销毁时，内部释放state
  39.     // [in] name  状态名称，为空名称为typedname的值
  40.     // [in] father_name 父状态的名称
  41.     // [out] 返回state
  42.     State* Context::CreateState(State* state, std::string name, std::string father_name)
  43.     {
  44.         NodeState node_state;
  45.         node_state._state = state;
  46.         node_state._state->SetContext(this);
  47.         node_state._father_name = father_name;
  48.         _states[name] = node_state;
  49.         return state;
  50.     }
  52.     // 更新当前状态
  53.     void Context::Update()
  54.     {
  55.         _cur_node_state._state->update();
  56.     }
  58.     // 同步事件
  59.     // 发送一个事件，提供给root状态和当前状态处理
  60.     // 如果当前状态是子状态，则还会给父状态处理
  61.     void Context::SendEvent(EventData event_data)
  62.     {
  63.         RecursiveSend(_cur_node_state, event_data);
  64.     }
  66.     // 异步事件
  67.     void Context::SendAsyncEvent(EventData event_data)
  68.     {
  69.         // todo 待实现
  70.     }
  72.     std::string Context::GetCurStateName()
  73.     {
  74.         return _cur_name;
  75.     }
  77.     // 递归send
  78.     void Context::RecursiveSend(NodeState& node_state, EventData& event_data)
  79.     {
  80.         EventDeal event_deal = node_state._state->RunEventFunc(event_data);
  81.         if (event_deal == keep_on
  82.             && !node_state._father_name.empty())
  83.         {
  84.             std::unordered_map<std::string, NodeState>::iterator iter_map = _states.find(node_state._father_name);
  85.             if (iter_map != _states.end())
  86.             {
  87.                 RecursiveSend(iter_map->second, event_data);
  88.             }
  89.         }
  90.     }
  92.     void Context::TransForState(std::string name)
  93.     {
  94.         std::string str_name = std::string(name);
  95.         std::unordered_map<std::string, NodeState>::iterator iter_map = _states.find(str_name);
  96.         if (iter_map != _states.end())
  97.         {
  98.             // 停止上一个状态
  99.             _cur_node_state._state->stop();
  101.             // 初始化下一个状态
  102.             _cur_node_state = iter_map->second;
  103.             _cur_name = iter_map->first;
  104.             _cur_node_state._state->start();
  105.         }
  106.     }
  107. }

state.h

  1. #ifndef _STATE_H_
  2. #define _STATE_H_
  3. #include "Event.h"
  4. #include<functional>
  5. #include<string>
  7. namespace HsmState
  8. {
  9.     class Context;
  11.     class State
  12.     {
  13.     public:
  15.         // 进入状态时调用，子类重写
  16.         virtual void start(){}
  18.         // 更新状态，可以由外部周期性调用
  19.         virtual void update(){}
  21.         // 停止状态是调用，子类重写
  22.         virtual void stop(){}
  24.         // 设置事件响应回调函数
  25.         void set_event_func(std::function<EventDeal(EventData&)> func);
  27.         EventDeal RunEventFunc(EventData& event_data); 
  29.         void SetContext(Context* context);
  31.         // 切换状态
  32.         // [in] name 状态名称
  33.         void TransState(std::string name);
  35.     private:
  36.         std::function<EventDeal(EventData&)> _event_func;
  37.         Context *_context;
  38.     };
  39. }
  40. #endif // !STATE_H_

state.cpp

  1. #include "Context.h"
  2. #include "State.h"
  4. namespace HsmState
  5. {
  6.     // 设置时间响应回调函数
  7.     void State::set_event_func(std::function<EventDeal(EventData&)> func)
  8.     {
  9.         _event_func = func;
  10.     }
  12.     EventDeal State::RunEventFunc(EventData& event_data)
  13.     {
  14.         if (_event_func == nullptr)
  15.             return keep_on;
  16.         return _event_func(event_data);
  17.     }
  19.     void State::SetContext(Context* context)
  20.     {
  21.         _context = context;
  22.     }
  24.     void State::TransState(std::string name)
  25.     {
  26.         _context->TransForState(name);
  27.     }
  28. }

event.h

  1. #pragma once
  3. namespace HsmState
  4. {
  5.     enum  EventDeal
  6.     {
  7.         tail = 0,   // 事件结束处理
  8.         keep_on // 事件继续传递
  9.     };
  11.     // 事件数据
  12.     class EventData
  13.     {
  14.     public:
  15.         EventData(int event_type)
  16.         {
  17.             _event_type = event_type;
  18.             _data = nullptr;
  19.         }
  21.         template <class T>
  22.         void SetData(T* t)
  23.         {
  24.             _data = t;
  25.         }
  27.         template <class T>
  28.         T* GetData()
  29.         {
  30.             return (T*)_data;
  31.         }
  34.         int _event_type;
  35.     private:
  36.         void* _data;
  37.     };
  38. }

应用举例

假如一个人一天生活状态变化：
有限状态机 - 图2
则OneDayState.cpp

  1. #include "Context.h"
  2. #include "State.h"
  3. #include <thread>
  4. #include <chrono>
  5. #include <iostream>
  6. #include <functional>
  8. using namespace HsmState;
  9. bool run = true;
  11. enum EventS
  12. {
  13.     belazy = 0, // 偷懒事件
  14. };
  16. // 开始状态
  17. class StartState : public State
  18. {
  19. public :
  20.     void start()
  21.     {
  22.         std::cout << "StartState start" << std::endl;
  23.     }
  25.     void stop()
  26.     {
  27.         std::cout << "StartState stop" << std::endl;
  28.     }
  30.     void update()
  31.     {
  32.         time++;
  33.         if (time == 10)
  34.         {
  35.             TransState("HungerState");
  36.         }
  37.     }
  39.     int time = 0;
  40. };
  42. // 饥饿状态
  43. class HungerState : public State
  44. {
  45. public:
  46.     void start()
  47.     {
  48.         std::cout << "HungerState start" << std::endl;
  49.     }
  51.     void stop()
  52.     {
  53.         std::cout << "HungerState stop" << std::endl;
  54.     }
  56.     void update()
  57.     {
  58.         time++;
  59.         if (time == 10)
  60.         {
  61.             TransState("Dinner");
  62.         }
  63.     }
  65.     int time = 0;
  66. };
  68. class Dinner : public State
  69. {
  70. public:
  71.     void start()
  72.     {
  73.         std::cout << "Dinner start" << std::endl;
  74.     }
  76.     void stop()
  77.     {
  78.         std::cout << "Dinner stop" << std::endl;
  79.     }
  81.     void update()
  82.     {
  83.         TransState("DoTheCookingState");
  84.     }
  85. };
  87. // 做饭状态
  88. class DoTheCookingState : public State
  89. {
  90. public:
  91.     void start()
  92.     {
  93.         std::cout << "DoTheCookingState start" << std::endl;
  94.     }
  96.     void stop()
  97.     {
  98.         std::cout << "DoTheCookingState stop" << std::endl;
  99.     }
  101.     void update()
  102.     {
  103.         time++;
  104.         if (time == 60)
  105.         {
  106.             TransState("EatState");
  107.         }
  108.     }
  110.     int time = 0;
  111. };
  114. // 吃饭状态
  115. class EatState : public State
  116. {
  117. public:
  118.     void start()
  119.     {
  120.         std::cout << "EatState start" << std::endl;
  121.     }
  123.     void stop()
  124.     {
  125.         std::cout << "EatState stop" << std::endl;
  126.     }
  128.     void update()
  129.     {
  130.         time++;
  131.         if (time == 5)
  132.         {
  133.             TransState("SleepState");
  134.         }
  135.     }
  137.     int time = 0;
  138. };
  141. // 饭后睡觉状态
  142. class SleepState : public State
  143. {
  144. public:
  145.     void start()
  146.     {
  147.         std::cout << "SleepState start" << std::endl;
  148.     }
  150.     void stop()
  151.     {
  152.         std::cout << "SleepState stop" << std::endl;
  153.     }
  155.     void update()
  156.     {
  157.         time++;
  158.         if (time == 30)
  159.         {
  160.             TransState("WorkState");
  161.         }
  162.     }
  164.     int time = 0;
  165. };
  167. // 工作状态
  168. class WorkState : public State
  169. {
  170. public:
  171.     void start()
  172.     {
  173.         std::cout << "WorkState start" << std::endl;
  175.         std::function<EventDeal(EventData&)> func = std::bind(&WorkState::DealEvent, this, std::placeholders::_1);;
  176.         set_event_func(func);
  177.     }
  179.     void stop()
  180.     {
  181.         std::cout << "WorkState stop" << std::endl;
  182.     }
  184.     EventDeal DealEvent(EventData &event_data)
  185.     {
  186.         switch ((EventS)event_data._event_type)
  187.         {
  188.         case belazy:
  189.             TransState("LoafOnAJob");
  190.             break;
  191.         default:
  192.             break;
  193.         }
  194.         return keep_on;
  195.     }
  197.     void update()
  198.     {
  199.         time++;
  200.         if (time == 180)
  201.         {
  202.             run = false;
  203.         }
  204.     }
  206.     int time = 0;
  207. };
  209. // 工作摸鱼状态
  210. class LoafOnAJob : public State
  211. {
  212. public:
  213.     void start()
  214.     {
  215.         time = 0;
  216.         std::cout << "LoafOnAJob start" << std::endl;
  217.     }
  219.     void stop()
  220.     {
  221.         std::cout << "LoafOnAJob stop" << std::endl;
  222.     }
  224.     void update()
  225.     {
  226.         time++;
  227.         if (time == 10)
  228.         {
  229.             TransState("WorkState");
  230.         }
  231.     }
  233.     int time = 0;
  234. };
  235. // 对象工厂
  236. class Factory
  237. {
  238. public :
  239.     static State* CreateState(Context* context, std::string name, std::string parent_name = "")
  240.     {
  241.         State* state = nullptr;
  242.         if (name == "StartState")
  243.         {
  244.             state = new StartState();
  245.         }
  246.         else if (name == "HungerState")
  247.         {
  248.             state = new HungerState();
  249.         }
  250.         else if (name == "Dinner")
  251.         {
  252.             state = new Dinner();
  253.         }
  254.         else if (name == "DoTheCookingState")
  255.         {
  256.             state = new DoTheCookingState();
  257.         }
  258.         else if (name == "EatState")
  259.         {
  260.             state = new EatState();
  261.         }
  262.         else if (name == "SleepState")
  263.         {
  264.             state = new SleepState();
  265.         }
  266.         else if (name == "WorkState")
  267.         {
  268.             state = new WorkState();
  269.         }
  270.         else if (name == "LoafOnAJob")
  271.         {
  272.             state = new LoafOnAJob();
  273.         }
  275.         context->CreateState(state, name, parent_name);
  276.         return state;
  277.     }
  278. };
  280. int main()
  281. {
  282.     Context* context = new Context();
  284.     // 创建状态机
  285.     Factory::CreateState(context, "StartState");
  286.     Factory::CreateState(context, "HungerState");
  287.     Factory::CreateState(context, "Dinner");
  288.     Factory::CreateState(context, "DoTheCookingState", "Dinner");
  289.     Factory::CreateState(context, "EatState", "Dinner");
  290.     Factory::CreateState(context, "SleepState");
  291.     Factory::CreateState(context, "WorkState");
  292.     Factory::CreateState(context, "LoafOnAJob");
  294.     // 开始状态机
  295.     context->Start("StartState");
  297.     int time = 0;
  298.     while (run)
  299.     {
  300.         time++;
  301.         std::this_thread::sleep_for(
  302.             std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::milliseconds(10)));
  304.         context->Update();
  306.         // 如果为工作状态，每隔60分钟发出偷懒事件
  307.         if (context->GetCurStateName() == "WorkState" 
  308.             && time % 60 == 0) 
  309.         {
  310.             EventData e = EventData((int)belazy);
  311.             context->SendEvent(e);
  312.         }
  313.     }
  315.     if (context)
  316.     {
  317.         delete context;
  318.         context = nullptr;
  319.     }
  321.     std::cout << "state close" << std::endl;
  322.     return 0;
  323. }

有限状态机 - 图3