函数指针方法实现简单状态机(附代码)

开发 后端
之前写过一篇状态机的实用文章,很多朋友说有几个地方有点难度不易理解,今天给大家换种简单写法,使用函数指针的方法实现状态机。

之前写过一篇状态机的实用文章,很多朋友说有几个地方有点难度不易理解,今天给大家换种简单写法,使用函数指针的方法实现状态机。

状态机简介

有限状态机FSM是有限个状态及在这些状态之间的转移和动作等行为的数学模型,是一种逻辑单元内部的高效编程方法,可以根据不同状态或者消息类型进行相应的处理逻辑,使得程序逻辑清晰易懂。

函数指针实现FSM

使用函数指针实现FSM可以分为3个步骤

  1. 建立相应的状态表和动作查询表
  2. 根据状态表、事件、动作表定位相应的动作处理函数
  3. 执行完成后再进行状态的切换

代码实现步骤

1.定义状态数据的枚举类型 

  1. typedef enum { 
  2.   state_1=1, 
  3.   state_2, 
  4.   state_3, 
  5.   state_4 
  6. }State; 

2.定义事件的枚举类型 

  1. typedef enum{ 
  2.   event_1=1, 
  3.   event_2, 
  4.   event_3, 
  5.   event_4, 
  6.   event_5 
  7. }EventID; 

3.定义状态表的数据类型 

  1. typedef struct 
  2.     int event;   //事件 
  3.     int CurState;  //当前状态 
  4.     void (*eventActFun)();  //函数指针 
  5.     int NextState;  //下一个状态 
  6. }StateTable; 

4.定义处理函数及建立状态表 

  1. void f121() 
  2.     printf("this is f121\n"); 
  3. void f221() 
  4.     printf("this is f221\n"); 
  5. void f321() 
  6.     printf("this is f321\n"); 
  7.  
  8. void f122() 
  9.     printf("this is f122\n"); 
  10.  
  11. StateTable fTable[] = 
  12.     //{到来的事件,当前的状态,将要要执行的函数,下一个状态} 
  13.     { event_1,  state_1,    f121,  event_2 }, 
  14.     { event_2,  state_2,    f221,  event_3 }, 
  15.     { event_3,  state_3,    f321,  event_4 }, 
  16.     { event_4,  state_4,    f122,  event_1 }, 
  17.     //add your code here 
  18. }; 

5.状态机类型,及状态机接口函数

  1. /*状态机类型*/ 
  2. typedef struct { 
  3.     int curState;//当前状态 
  4.     StateTable * stateTable;//状态表 
  5.     int size;//表的项数 
  6. }fsmType; 
  7.  
  8. /*状态机注册,给它一个状态表*/ 
  9. void fsmRegist(fsmType* pFsm, StateTable* pTable) 
  10.     pFsm->stateTable = pTable; 
  11.  
  12. /*状态迁移*/ 
  13. void fsmStateTransfer(fsmType* pFsm, int state) 
  14.     pFsm->curState = state; 
  15.  
  16. /*事件处理*/ 
  17. void fsmEventHandle(fsmType* pFsm, int event) 
  18.     StateTable* pActTable = pFsm->stateTable; 
  19.     void (*eventActFun)() = NULL;  //函数指针初始化为空 
  20.     int NextState; 
  21.     int CurState = pFsm->curState; 
  22.     int maxNum = pFsm->size
  23.     int flag = 0; //标识是否满足条件 
  24.  
  25.     /*获取当前动作函数*/ 
  26.     for (int i = 0; i<maxNum; i++) 
  27.     { 
  28.         //当且仅当当前状态下来个指定的事件,我才执行它 
  29.         if (event == pActTable[i].event && CurState == pActTable[i].CurState) 
  30.         { 
  31.             flag = 1; 
  32.             eventActFun = pActTable[i].eventActFun; 
  33.             NextState = pActTable[i].NextState; 
  34.             break; 
  35.         } 
  36.     } 
  37.  
  38.  
  39.     if (flag) //如果满足条件了 
  40.     { 
  41.         /*动作执行*/ 
  42.         if (eventActFun) 
  43.         { 
  44.             eventActFun(); 
  45.         } 
  46.  
  47.         //跳转到下一个状态 
  48.         fsmStateTransfer(pFsm, NextState); 
  49.     } 
  50.     else 
  51.     { 
  52.         printf("there is no match\n"); 
  53.     } 

 

附代码

代码直接复制过去就行啦,本想打包的,太麻烦了。

测试程序

  1. //编译器:http://www.dooccn.com/cpp/ 
  2. //来源:技术让梦想更伟大 
  3. //作者:李肖遥 
  4. #include <stdio.h> 
  5.  
  6. typedef enum { 
  7.   state_1=1, 
  8.   state_2, 
  9.   state_3, 
  10.   state_4 
  11. }State; 
  12.  
  13. typedef enum{ 
  14.   event_1=1, 
  15.   event_2, 
  16.   event_3, 
  17.   event_4, 
  18.   event_5 
  19. }EventID; 
  20.  
  21. typedef struct { 
  22.     int event;   //事件 
  23.     int CurState;  //当前状态 
  24.     void (*eventActFun)();  //函数指针 
  25.     int NextState;  //下一个状态 
  26. }StateTable; 
  27.  
  28. void f121() 
  29.     printf("this is f121\n"); 
  30. void f221() 
  31.     printf("this is f221\n"); 
  32. void f321() 
  33.     printf("this is f321\n"); 
  34.  
  35. void f122() 
  36.     printf("this is f122\n"); 
  37.  
  38. StateTable fTable[] = 
  39.     //{到来的事件,当前的状态,将要要执行的函数,下一个状态} 
  40.     { event_1,  state_1,    f121,  event_2 }, 
  41.     { event_2,  state_2,    f221,  event_3 }, 
  42.     { event_3,  state_3,    f321,  event_4 }, 
  43.     { event_4,  state_4,    f122,  event_1 }, 
  44.     //add your code here 
  45. }; 
  46.  
  47. /*状态机类型*/ 
  48. typedef struct { 
  49.     int curState;//当前状态 
  50.     StateTable * stateTable;//状态表 
  51.     int size;//表的项数 
  52. }fsmType; 
  53.  
  54. /*状态机注册,给它一个状态表*/ 
  55. void fsmRegist(fsmType* pFsm, StateTable* pTable) 
  56.     pFsm->stateTable = pTable; 
  57.  
  58. /*状态迁移*/ 
  59. void fsmStateTransfer(fsmType* pFsm, int state) 
  60.     pFsm->curState = state; 
  61.  
  62. /*事件处理*/ 
  63. void fsmEventHandle(fsmType* pFsm, int event) 
  64.     StateTable* pActTable = pFsm->stateTable; 
  65.     void (*eventActFun)() = NULL;  //函数指针初始化为空 
  66.     int NextState; 
  67.     int CurState = pFsm->curState; 
  68.     int maxNum = pFsm->size
  69.     int flag = 0; //标识是否满足条件 
  70.  
  71.     /*获取当前动作函数*/ 
  72.     for (int i = 0; i<maxNum; i++) 
  73.     { 
  74.         //当且仅当当前状态下来个指定的事件,我才执行它 
  75.         if (event == pActTable[i].event && CurState == pActTable[i].CurState) 
  76.         { 
  77.             flag = 1; 
  78.             eventActFun = pActTable[i].eventActFun; 
  79.             NextState = pActTable[i].NextState; 
  80.             break; 
  81.         } 
  82.     } 
  83.  
  84.  
  85.     if (flag) //如果满足条件了 
  86.     { 
  87.         /*动作执行*/ 
  88.         if (eventActFun) 
  89.         { 
  90.             eventActFun(); 
  91.         } 
  92.  
  93.         //跳转到下一个状态 
  94.         fsmStateTransfer(pFsm, NextState); 
  95.     } 
  96.     else 
  97.     { 
  98.         printf("there is no match\n"); 
  99.     } 
  100.  
  101. int main() 
  102.     fsmType pType; 
  103.     fsmRegist(&pType,fTable); 
  104.     pType.curState = state_1; 
  105.     pType.size = sizeof(fTable)/sizeof(StateTable); 
  106.  
  107.  
  108.     printf("init state:%d\n\n",pType.curState); 
  109.  
  110.     fsmEventHandle(&pType,event_1); 
  111.     printf("state:%d\n\n",pType.curState); 
  112.  
  113.     fsmEventHandle(&pType,event_2); 
  114.     printf("state:%d\n\n",pType.curState); 
  115.  
  116.     fsmEventHandle(&pType,event_3); 
  117.     printf("state:%d\n\n",pType.curState); 
  118.  
  119.     fsmEventHandle(&pType,event_4); 
  120.     printf("state:%d\n\n",pType.curState); 
  121.  
  122.     fsmEventHandle(&pType,event_2); 
  123.     printf("state:%d\n\n",pType.curState); 
  124.  
  125.     return 0; 

编译结果 

 

 

 

总结

使用函数指针实现的FSM的过程还是比较费时费力的,但是这一切相对一大堆的if/else、switch/case来说都是值得的,当你的程序规模变得越来越大的时候,基于这种表结构的状态机,维护程序起来会清晰很多。 

责任编辑:庞桂玉 来源: C语言与C++编程
相关推荐

2021-12-28 08:24:18

函数指针有限状态机编程

2011-06-24 16:09:24

Qt 动画 状态机

2023-03-06 07:35:30

状态机工具订单状态

2010-06-18 13:15:07

UML状态机图

2010-06-18 12:38:38

UML状态机视图

2013-09-03 09:57:43

JavaScript有限状态机

2010-06-18 13:25:44

UML状态机视图

2021-07-08 09:15:20

单片机编程状态机编程语言

2011-06-29 18:36:59

Qt 动画 状态机

2020-10-15 10:38:35

C语言状态模型

2024-01-08 09:46:47

2021-06-05 05:11:52

代码状态机逻辑

2010-07-08 13:03:31

UML状态机图

2020-03-27 10:50:29

DSL 状态机工具

2021-08-19 09:00:00

微服务开发架构

2022-03-06 19:57:50

状态机easyfsm项目

2010-07-12 15:00:56

UML状态机视图

2021-04-29 09:31:05

前端开发技术

2010-02-24 09:32:38

Visual Stud

2011-08-22 10:52:30

iptables状态
点赞
收藏

51CTO技术栈公众号