devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【算法】有限状态机FSM_有限状态机算法

作者：正经夜光杯 | 2024-08-01 19:24:03

赞

踩

有限状态机算法

目录

一、快速理解

1、有限状态机（FSM）

2、有限状态机的设计

二、详细说明

1、有限状态机FSM

1）FSM概念

2）FSM的3特点

3）FSM的4要素

4）FSM状态转换图

2、FSM的设计和实现

1）设计思路

2）两种实现方式

3、通用FSM的设计

一、快速理解

有限状态机（FSM）的设计与实现（一）

1、有限状态机（FSM）

有限状态机（FSM）是表示有限个状态及在这些状态之间的转移和动作等行为的数学模型，在计算机领域有着广泛的应用。通常FSM包含几个要素：状态的管理、状态的监控、状态的触发、状态触发后引发的动作。

2、有限状态机的设计

本文主要阐述一下状态机的几种设计方法。

1：switch case/if else设计方法

 

  1. curEvent = getEvent();
  2. curState = getCurState();
  3. switch(curState)
  4. {
  5.     case state1:
  6.     {
  7.         switch(curEvent )
  8.         {
  9.              TODO...
  10.              setCurState();
  11.              break; 
  12.         }
  13.         break;
  14.     }
  15.     ...
  16. }

 

这种设计方法最简单，通过一大堆判断来处理，适合小规模的状态切换流程，但如果规模扩大难以扩展和维护。

2：基于表结构的状态机设计方法：建立相应的状态表和动作查询表，根据状态表、事件、动作表定位相应的动作处理函数，执行完成后再进行状态的切换。

一个通用的状态机处理模块的设计如下：

  1.  
  2. /*状态表注册*/
  3. void FSM_Regist(FSM_T* pFsm,STATE_TABLE_S* pStateTable)
  4. {
  5.    pFsm->FsmTable =  pStateTable;
  6.    return;
  7. }
  8. /*状态迁移*/
  9. void FSM_MoveState(FSM_T* pFsm,int state)
  10. {
  11.    pFsm->curState = state;
  12.    return;
  13. }
  14. /*事件处理*/
  15. void FSM_EventHandle(FSM_T* pFsm,int event)
  16. {
  17.     ACT_TABLE_T* pActTable = NULL;
  18.     ActFun eventActFun = NULL;
  19.     /*获取当前状态动作表*/
  20.     pActTable = FSM_getActTable(pFsm);
  21.     /*获取当前动作函数*/
  22.     for(int i=0;i<MAX_ACT_NUM;i++)
  23.     {
  24.         if(event == pActTable[i].event)
  25.         {
  26.             eventActFun = pActTable[i].eventActFun;
  27.             break;
  28.         }
  29.     }
  30.     /*动作执行*/
  31.     if(eventActFun)
  32.     {
  33.         eventActFun(pFsm);
  34.     }
  35. }

假设我们的状态图如下：


相应的状态机设置如下：

 

  1. /*状态1的动作表*/
  2. ACT_TABLE_T state1ActTable[] = {
  3.     {EVENT1,state1Event1Fun},
  4.     {EVENT3,state1Event3Fun},
  5. };
  6. /*状态2的动作表*/
  7. ACT_TABLE_T state2ActTable[] = {
  8.     {EVENT2,state2Event2Fun},
  9. };
  10. /*状态表*/
  11. STATE_TABLE_T FsmTable[] = {
  12.     {STATE1,state1ActTable},
  13.     {STATE2,state2ActTable},
  14. };
  15.  
  16. int main(int argc, _TCHAR* argv[])
  17. {
  18.     FSM_T fsm;
  19.     /*状态表注册*/
  20.     FSM_Regist(&fsm,FsmTable);
  21.     FSM_MoveState(&fsm,STATE1);
  22.     FSM_EventHandle(&fsm,EVENT1);
  23.     FSM_EventHandle(&fsm,EVENT2);
  24.     return 0;
  25. }
  26. /*客户端提供的状态处理函数*/
  27. void state1Event1Fun(void* pFsm)
  28. {
  29.     FSM_MoveState((FSM_T*)pFsm,STATE2);
  30.     return;
  31. }
  32. void state1Event3Fun(void* pFsm)
  33. {
  34.     FSM_MoveState((FSM_T*)pFsm,STATE3);
  35.     return;
  36. }
  37. void state2Event2Fun(void* pFsm)
  38. {
  39.     FSM_MoveState((FSM_T*)pFsm,STATE3);
  40.     return;
  41. }

通过设计一个通用的基于表结构的状态机模块，针对不同的状态图，我们只需要根据状态图得到其状态表结构，然后通过FSM_Regist注册，就可以方便的使用了状态机的功能了。这种机制便于我们添加新的状态流程，并且可以很好的进行分层状态机的设计。

二、详细说明

1、有限状态机FSM

现实问题

在平时的工作中，有时候我们会遇到需要处理诸多状态的情况，譬如订单状态，简单罗列就有12种状态

  1. "0": "交易关闭",
  2. "1": "待支付",
  3. "2": "支付确认中",
  4. "3": "支付中",
  5. "4": "待收货",
  6. "5": "交易成功", // 已签收
  7. "-1": "交易关闭", // 订单已取消
  8. "-2": "交易关闭,退款中",
  9. "-3": "交易关闭,已退款",
  10. "-4": "订单异常",
  11. "-5": "退货退款中",
  12. "-6": "已退货退款"

 

而且这些状态之间存在联系。比如待支付状态下一个可能是支付确认中，可能是交易关闭，也可能是交易成功。

如何处理这么多的状态以及之间的关系，我们需要一个状态管理的机制，来统一处理，这里就需要FSM.

 

1）FSM概念

FSM(finite-state machine):表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。

 

2）FSM的3特点

  1. 一个时刻，只有一个状态。
  2. 某种条件下，会从一种状态转变（transition）到另一种状态。（比如待支付的下个状态是支付成功）
  3. 状态有限(finite)

 

3）FSM的4要素

  1. currentState(当前状态)
  2. nextState(下一个状态)
  3. transition(currentState,action)。当前状态和下个状态的关系。接收当前的状态，根据不同的action返回不同的nextState.
  4. action.state变动的event

4）FSM状态转换图

假设一个状态机的输入是 字符：

有限状态机,也称为FSM(Finite State Machine)，其在任意时刻都处于有限状态集合中的某一状态。当其获得一个输入字符时，将从当前状态转换到另一个状态，或者仍然保持在当前状态。任何一个FSM都可以用状态转换图来描述，图中的节点表示FSM中的一个状态，有向加权边表示输入字符时状态的变化。如果图中不存在与当前状态与输入字符对应的有向边，则FSM将进入“消亡状态(Doom State)”，此后FSM将一直保持“消亡状态”。状态转换图中还有两个特殊状态：状态1称为“起始状态”，表示FSM的初始状态。状态6称为“结束状态”，表示成功识别了所输入的字符序列。

在启动一个FSM时，首先必须将FSM置于“起始状态”，然后输入一系列字符，最终，FSM会到达“结束状态”或者“消亡状态”。

说明：

在通常的FSM模型中，一般还存在一个“接受状态”，并且FSM可以从“接受状态”转换到另一个状态，只有在识别最后一个输入后，才会根据最终状态来决定是否接受所输入的字符。此外，也可以将“其实状态”也作为接受状态，因此空的输入序列也是可以接受的。

2、FSM的设计和实现

1）设计思路

程序设计思路大致如下：

  • 使用状态转换图描述FSM
  • 状态转换图中的结点对应不同的状态对象
  • 每个状态对象通过一个输入字符转换到另一个状态上，或者保持原状态不变。

通过输入字符从一个状态切换到另一个状态的过程，我们称之为一个映射。在计算机程序设计中，我们可以有两种表示映射的方法：

  • 通过算法表示，即“可执行代码（Executable Code）”方式
  • 通过一张映射表，即“被动数据（Passive Data）”方式

2）两种实现方式

如下详细介绍这两种实现方式：

  • 通过Executable Code实现映射的FSM：（if或者switch）

这种方式主要是通过条件分支来处理不同的字符，如if或者switch语句块，如

  1. State* State1::Transition(char c)
  2. {
  3.     switch(c)
  4.     {
  5.     case 'A':
  6.         return &s2;
  7.     case 'B':
  8.         return &s3;
  9.     case 'C':
  10.         return &s4;
  11.     case 'D':
  12.         return &s5;
  13.     case '\0':
  14.         return NULL;
  15.     default:
  16.         return NULL;
  17.     }
  18. }
  1. // fsm_with_executable_code.h
  2. #ifndef FSM_WITH_EXECUTABLE_CODE_H
  3. #define FSM_WITH_EXECUTABLE_CODE_H
  4.  
  5. #include <string.h>
  6.  
  7. class State
  8. {
  9. public:
  10.     virtual State* Transition(char c) = 0;
  11. };
  12.  
  13. class Fsm
  14. {
  15. public:
  16.     Fsm();
  17.     void Reset();            // move to start state
  18.     void Advance(char c);    // advance one transition
  19.     int EndState();
  20.     int DoomState();
  21.  
  22. private:
  23.     State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom
  24. };
  25.  
  26.  
  27. class State1 : public State
  28. {
  29. public:
  30.     State* Transition(char c);
  31. };
  32.  
  33. class State2 : public State
  34. {
  35. public:
  36.     State* Transition(char c);
  37. };
  38.  
  39. class State3 : public State
  40. {
  41. public:
  42.     State* Transition(char c);
  43. };
  44.  
  45. class State4 : public State
  46. {
  47. public:
  48.     State* Transition(char c);
  49. };
  50.  
  51. class State5 : public State
  52. {
  53. public:
  54.     State* Transition(char c);
  55. };
  56.  
  57. class State6 : public State
  58. {
  59. public:
  60.     State* Transition(char c);
  61. };
  62.  
  63. #endif // FSM_WITH_EXECUTABLE_CODE_H
  64.  
  65. // fsm_with_executable_code.cc
  66. #include "fsm_with_executable_code.h"
  67.  
  68. State1 s1;
  69. State2 s2;
  70. State3 s3;
  71. State4 s4;
  72. State5 s5;
  73. State6 s6;
  74.  
  75. Fsm::Fsm()
  76. {
  77.     p_current = NULL;
  78. }
  79.  
  80. void Fsm::Reset()
  81. {
  82.     p_current = &s1;
  83. }
  84.  
  85. void Fsm::Advance(char c)
  86. {
  87.     if (p_current != NULL)
  88.         p_current = p_current->Transition(c);
  89. }
  90.  
  91. int Fsm::EndState()
  92. {
  93.     return p_current == &s6;
  94. }
  95.  
  96. int Fsm::DoomState()
  97. {
  98.     return p_current == NULL;
  99. }
  100. State* State1::Transition(char c)
  101. {
  102.     switch(c)
  103.     {
  104.     case 'A':
  105.         return &s2;
  106.     case 'B':
  107.         return &s3;
  108.     case 'C':
  109.         return &s4;
  110.     case 'D':
  111.         return &s5;
  112.     case '\0':
  113.         return NULL;
  114.     default:
  115.         return NULL;
  116.     }
  117. }
  118.  
  119. State* State2::Transition(char c)
  120. {
  121.     switch(c)
  122.     {
  123.     case 'E':
  124.         return &s2;
  125.     case 'I':
  126.         return &s6;
  127.     case '\0':
  128.         return NULL;
  129.     default:
  130.         return NULL;
  131.     }
  132. }
  133.  
  134. State* State3::Transition(char c)
  135. {
  136.     switch(c)
  137.     {
  138.     case 'F':
  139.         return &s3;
  140.     case 'M':
  141.         return &s4;
  142.     case 'J':
  143.         return &s6;
  144.     case '\0':
  145.         return NULL;
  146.     default:
  147.         return NULL;
  148.     }
  149. }
  150.  
  151. State* State4::Transition(char c)
  152. {
  153.     switch(c)
  154.     {
  155.     case 'G':
  156.         return &s4;
  157.     case 'K':
  158.         return &s6;
  159.     case '\0':
  160.         return NULL;
  161.     default:
  162.         return NULL;
  163.     }
  164. }
  165.  
  166. State* State5::Transition(char c)
  167. {
  168.     switch(c)
  169.     {
  170.     case 'O':
  171.         return &s2;
  172.     case 'H':
  173.         return &s5;
  174.     case 'L':
  175.         return &s6;
  176.     case 'N':
  177.         return &s4;
  178.     case '\0':
  179.         return NULL;
  180.     default:
  181.         return NULL;
  182.     }
  183. }
  184.  
  185. State* State6::Transition(char c)
  186. {
  187.     return NULL;
  188. }
  189.  
  190. // test_with_executable_code.cc
  191. #include "fsm_with_executable_code.h"
  192.  
  193. #include "stdio.h"  // printf, scanf
  194. #include "stdlib.h" // system
  195.  
  196. void test_fsm()
  197. {
  198.     char input_string[80];
  199.     printf("Enter input expression: ");
  200.     scanf("%s", input_string);
  201.  
  202.     Fsm fsm;
  203.     fsm.Reset();
  204.     int index = 0;
  205.     fsm.Advance(input_string[index++]);
  206.  
  207.     while (!fsm.EndState() && !fsm.DoomState())
  208.         fsm.Advance(input_string[index++]);
  209.  
  210.     if (fsm.EndState())
  211.         printf("\nValid input expression");
  212.     else
  213.         printf("\nInvalid input expression");
  214. }
  215.  
  216. int main()
  217. {
  218.     test_fsm();
  219.  
  220.     system("pause");
  221. }

  •  通过Passive Data实现映射的FSM：（表）

在如上的switch分支中，其使用类型大致相同，因此，我们可以考虑将相似的信息保存到一张表中，这样就可以在程序中避免很多函数调用。在每个状态中都使用一张转换表来表示映射关系，转换表的索引使用输入字符来表示。此外，由于通过转换表就可以描述不同状态之间的变化，那么就没有必要将每种状态定义为一个类了，即不需要多余的继承和虚函数了，仅使用一个State即可。

  1. #include <limits.h>
  2. class State
  3. {
  4. public:
  5.     State();
  6.     State* transition[range];
  7. };
  8.  
  9. 对于任意一个状态state和输入字符c，后续状态都可以通过state.transition[c]来确定。
  10.  
  11. 类Fsm中的成员state包含6个状态，为了对应方便，我们将结束状态放在state[0]中，每个状态都使用一个三元组 { 当前状态，输入字符，下一个状态 } 来表示：
  12. struct TransGraph   // use triple to describe map
  13. {
  14.     int current_state;
  15.     char input_char;
  16.     int next_state;
  17. };

如此，使用了转换表代替了虚函数，简化了程序的设计。

  1. // fsm_with_passive_data.h
  2. #ifndef FSM_WITH_PASSIVE_DATA_H
  3. #define FSM_WITH_PASSIVE_DATA_H
  4.  
  5. #include <string.h>
  6. #include <limits.h>     // CHAR_MAX
  7.  
  8. const int range = CHAR_MAX + 1;
  9.  
  10. class State
  11. {
  12. public:
  13.     State();
  14.     State* transition[range];
  15. };
  16.  
  17. struct TransGraph   // use triple to describe map
  18. {
  19.     int current_state;
  20.     char input_char;
  21.     int next_state;
  22. };
  23.  
  24. class Fsm
  25. {
  26. public:
  27.     Fsm();
  28.     void Reset();            // move to start state
  29.     void Advance(char c);    // advance one transition
  30.     int EndState();
  31.     int DoomState();
  32.  
  33. private:
  34.     State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom
  35.     State state[6];     // 6 states, state[0] is end state
  36. };
  37.  
  38.  
  39. #endif // FSM_WITH_PASSIVE_DATA_H
  40.  
  41. // fsm_with_passive_data.cc
  42. #include "fsm_with_passive_data.h"
  43.  
  44. State::State()
  45. {
  46.     for (int i = 0; i < range; ++i)
  47.         transition[i] = NULL;
  48. }
  49.  
  50. Fsm::Fsm()
  51. {
  52.     static TransGraph graph[] =
  53.     {
  54.         {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},
  55.         {2, 'E', 2}, {2, 'I', 0},
  56.         {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},
  57.         {4, 'G', 4}, {4, 'K', 0},
  58.         {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},
  59.         {0, 0, 0}
  60.     };
  61.  
  62.     for (TransGraph* p_tg = graph; p_tg->current_state != 0; ++p_tg)
  63.         state[p_tg->current_state].transition[p_tg->input_char] = &state[p_tg->next_state];
  64.  
  65.     p_current = NULL;
  66. }
  67.  
  68. void Fsm::Reset()
  69. {
  70.     p_current = &state[1];
  71. }
  72.  
  73. void Fsm::Advance(char c)
  74. {
  75.     if (p_current != NULL)
  76.         p_current = p_current->transition[c];
  77. }
  78.  
  79. int Fsm::EndState()
  80. {
  81.     return p_current == &state[0];
  82. }
  83.  
  84. int Fsm::DoomState()
  85. {
  86.     return p_current == NULL;
  87. }
  88.  
  89. // test_with_passive_data.cc
  90. #include "fsm_with_passive_data.h"
  91. #include "stdio.h"  // printf, scanf
  92. #include "stdlib.h" // system
  93.  
  94. void test_fsm()
  95. {
  96.     char input_string[80];
  97.     printf("Enter input expression: ");
  98.     scanf("%s", input_string);
  99.  
  100.     Fsm fsm;
  101.     fsm.Reset();
  102.     int index = 0;
  103.     fsm.Advance(input_string[index++]);
  104.  
  105.     while (!fsm.EndState() && !fsm.DoomState())
  106.         fsm.Advance(input_string[index++]);
  107.  
  108.     if (fsm.EndState())
  109.         printf("\nValid input expression");
  110.     else
  111.         printf("\nInvalid input expression");
  112. }
  113.  
  114.  
  115. int main()
  116. {
  117.     test_fsm();
  118.  
  119.     system("pause");
  120. }

3、通用FSM的设计

如果类Fsm可以表示任意类型的FSM，那么就更符合程序设计的要求了。在构造函数中执行的具体配置应该被泛化为一种机制，我们通过这种机制来建立任意的FSM。在Fsm的构造函数中，应该将转换表作为一个参数传入，而非包含具体的转换表，如此，则不需要将转换表的大小硬编码到Fsm中了。因此，在构造函数中必须动态地创建这个存放转换表的内存空间，在析构函数中记着销毁这块内存。

具体配置------>泛化----->一种机制

转换表    ------>泛化----->参数传入

  1. class Fsm
  2. {
  3. public:
  4.     Fsm(TransGraph* p_tg);//原来的： Fsm();
  5.     virtual ~Fsm();
  6.     void Reset();
  7.     void Advance(char c);
  8.     int EndState();
  9.     int DoomState();
  10.  
  11. private:
  12.     State* p_current;
  13.     State* p_state;   //原来的： State state[6];     // 6 states, state[0] is end state
  14. };
  15.  
  16. Fsm::Fsm(TransGraph* p_tg)
  17. {
  18.     int max_state = 0;  // size for dynamically allocated graph
  19.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
  20.     {
  21.         if (p_temp->current_state > max_state)
  22.             max_state = p_temp->current_state;
  23.         if (p_temp->next_state > max_state)
  24.             max_state = p_temp->next_state;
  25.     }
  26.  
  27.     p_state = new State[max_state + 1];
  28.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
  29.         p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];
  30.  
  31.     p_current = NULL;
  32. }
  33.  
  34. Fsm::~Fsm()
  35. {
  36.     delete []p_state;
  37. }
  1. // fsm_with_generalization.h
  2. #ifndef FSM_WITH_GENERALIZATION_H
  3. #define FSM_WITH_GENERALIZATION_H
  4.  
  5. #include <string.h>
  6. #include <limits.h>     // CHAR_MAX
  7.  
  8. const int range = CHAR_MAX + 1;
  9.  
  10. class State
  11. {
  12. public:
  13.     State();
  14.     State* transition[range];
  15. };
  16.  
  17. struct TransGraph
  18. {
  19.     int current_state;
  20.     char input_char;
  21.     int next_state;
  22. };
  23.  
  24. class Fsm
  25. {
  26. public:
  27.     Fsm(TransGraph* p_tg);
  28.     virtual ~Fsm();
  29.     void Reset();
  30.     void Advance(char c);
  31.     int EndState();
  32.     int DoomState();
  33.  
  34. private:
  35.     State* p_current;
  36.     State* p_state;
  37. };
  38.  
  39.  
  40. #endif // FSM_WITH_GENERALIZATION_H
  41.  
  42. // fsm_with_generalization.cc
  43. #include "fsm_with_generalization.h"
  44.  
  45. State::State()
  46. {
  47.     for (int i = 0; i < range; ++i)
  48.         transition[i] = NULL;
  49. }
  50.  
  51. Fsm::Fsm(TransGraph* p_tg)
  52. {
  53.     int max_state = 0;  // size for dynamically allocated graph
  54.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
  55.     {
  56.         if (p_temp->current_state > max_state)
  57.             max_state = p_temp->current_state;
  58.         if (p_temp->next_state > max_state)
  59.             max_state = p_temp->next_state;
  60.     }
  61.  
  62.     p_state = new State[max_state + 1];
  63.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
  64.         p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];
  65.  
  66.     p_current = NULL;
  67. }
  68.  
  69. Fsm::~Fsm()
  70. {
  71.     delete []p_state;
  72. }
  73.  
  74. void Fsm::Reset()
  75. {
  76.     p_current = &p_state[1];
  77. }
  78.  
  79. void Fsm::Advance(char c)
  80. {
  81.     if (p_current != NULL)
  82.         p_current = p_current->transition[c];
  83. }
  84.  
  85. int Fsm::EndState()
  86. {
  87.     return p_current == &p_state[0];
  88. }
  89.  
  90. int Fsm::DoomState()
  91. {
  92.     return p_current == NULL;
  93. }
  94.  
  95. // test_with_generalization.cc
  96. #include "fsm_with_generalization.h"
  97.  
  98. #include "stdio.h"  // printf, scanf
  99. #include "stdlib.h" // system
  100.  
  101. void test_fsm()
  102. {
  103.     char input_string[80];
  104.     printf("Enter input expression: ");
  105.     scanf("%s", input_string);
  106.  
  107.     TransGraph graph[] =
  108.     {
  109.         {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},
  110.         {2, 'E', 2}, {2, 'I', 0},
  111.         {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},
  112.         {4, 'G', 4}, {4, 'K', 0},
  113.         {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},
  114.         {0, 0, 0}
  115.     };
  116.  
  117.     Fsm fsm(graph);
  118.     fsm.Reset();
  119.     int index = 0;
  120.     fsm.Advance(input_string[index++]);
  121.  
  122.     while (!fsm.EndState() && !fsm.DoomState())
  123.         fsm.Advance(input_string[index++]);
  124.  
  125.     if (fsm.EndState())
  126.         printf("\nValid input expression");
  127.     else
  128.         printf("\nInvalid input expression");
  129. }
  130.  
  131.  
  132. int main()
  133. {
  134.     test_fsm();
  135.  
  136.     system("pause");
  137. }

当然也可以将上述程序中的转换表不放在主程序中，而是由一个派生自Fsm的子类SpecificFsm提供，在SpecificFsm中设置具体的转换表，然后通过SpecificFsm的初始化列表传到基类Fsm中，这样在主程序中就可以使用SpecificFsm来进行操作了。

原文：https://www.cnblogs.com/chencheng/archive/2012/06/25/2562660.html

未消化：

使用C++实现一套简单的状态机模型——实例：https://fangliang.blog.csdn.net/article/details/44042287

使用C++实现一套简单的状态机模型——原理解析：https://fangliang.blog.csdn.net/article/details/44120809

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/915550
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号