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

状态机简介

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

函数指针实现FSM

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

• 建立相应的状态表和动作查询表

• 根据状态表、事件、动作表定位相应的动作处理函数

• 执行完成后再进行状态的切换

  
  ) R6 V+ k  E  J; P1 j& c7 C, A

代码实现步骤

• 定义状态数据的枚举类型
  $ l4 y% o# d3 D% j" t8 h6 M0 W$ V7 d5 N

typedef enum {
" `/ t' z  @; ]9 e  state_1=1,
  state_2,
  state_3,
- e* K2 ]$ X8 T  state_4
+ E1 e3 Y. T8 r5 O3 p' J$ R}State;

• 定义事件的枚举类型
  : {8 j5 D( F. h0 P

typedef enum{
  event_1=1,
7 F. N# _/ P4 ^# f  event_2,
  event_3,
  event_4,
) A8 \& a' I+ z$ D  event_5
}EventID;

• 定义状态表的数据类型
  

typedef struct
{
    int event;   //事件
1 d+ _4 K. b% L, ]- c/ }    int CurState;  //当前状态
    void (*eventActFun)();  //函数指针
/ _) ~9 k- t+ s( i6 q7 }3 H% T    int NextState;  //下一个状态
}StateTable;

• 定义处理函数及建立状态表
  3 t" g$ P2 ~' k0 V+ O

void f121()
{
    printf("this is f121\n");
- Q9 V  F3 x) E( |}
void f221()
{
    printf("this is f221\n");
}
; r" b9 |' ?: r" h! Q6 [void f321()
1 P  v" H& e( C! t5 v, e) P{
1 R: G+ X$ o& Y4 N9 i  o! G    printf("this is f321\n");
5 y3 b7 Q0 I8 l8 M- x% E2 A}

) V! G  d  Q& Cvoid f122()
0 p0 B4 A; X% C1 \{
4 d4 n  l  T$ c- Y7 X    printf("this is f122\n");
% t1 [2 n6 L( V}

8 A( t5 b- U1 r- J" }$ n' g1 p& FStateTable fTable[] =
3 a0 c* F; U4 p% {) v{
+ D- w. m9 P+ R; o: s- c    //{到来的事件，当前的状态，将要要执行的函数，下一个状态}
9 @4 Y# Z: H5 e" L8 x/ e* |+ Z    { event_1,  state_1,    f121,  event_2 },
    { event_2,  state_2,    f221,  event_3 },
! d- O/ ]8 n' M    { event_3,  state_3,    f321,  event_4 },
, Z7 }4 S: g1 k5 l0 L% t3 @    { event_4,  state_4,    f122,  event_1 },
    //add your code here
6 e+ d0 I* \, U6 v; ~};

• 状态机类型，及状态机接口函数
  ; j% b+ M2 w2 C) F1 r: d' \8 Y

/*状态机类型*/
typedef struct {
  w, [9 e2 b4 L. m. O& D- l    int curState;//当前状态
    StateTable * stateTable;//状态表
    int size;//表的项数
7 k' ~7 y0 i% d+ c9 L6 m}fsmType;
1 [4 t1 T0 {' Z) _6 ?
/*状态机注册,给它一个状态表*/
* k  [( T  `0 Z7 C8 {void fsmRegist(fsmType* pFsm, StateTable* pTable)
& H! v+ W5 [/ ^{
" u: B+ @5 f. a5 Z7 G' K5 a    pFsm->stateTable = pTable;
}

) B. B- Z% l8 u/*状态迁移*/
, r" j, G% {/ o" [+ {void fsmStateTransfer(fsmType* pFsm, int state)
' g- j6 M" L4 p' ]- @{
    pFsm->curState = state;
}

/*事件处理*/
void fsmEventHandle(fsmType* pFsm, int event)
! p3 ~& C" K0 A2 K# V{
    StateTable* pActTable = pFsm->stateTable;
! G% B5 p# u, f, n& O, z7 k1 g; F    void (*eventActFun)() = NULL;  //函数指针初始化为空
( i, W* S" T% N2 e  D" e4 b    int NextState;
    int CurState = pFsm->curState;
    int maxNum = pFsm->size;
2 X8 x" Z6 _$ b8 K4 s    int flag = 0; //标识是否满足条件

    /*获取当前动作函数*/
, q3 Q  V) u# @* y8 Q+ J    for (int i = 0; i<maxNum; i++)
5 @$ t' c% ]. G1 j, t6 K: d( L8 }    {
        //当且仅当当前状态下来个指定的事件，我才执行它
        if (event == pActTable.event && CurState == pActTable.CurState)
% E% @9 V8 @0 }        {
2 k% b# {5 p& `            flag = 1;
0 X& ~  `7 W: U: c  o  N7 N8 p            eventActFun = pActTable.eventActFun;
            NextState = pActTable.NextState;
. D- T+ T8 t& u/ f            break;
8 X% ^* Q5 C9 w; C9 l& j        }
4 C" d5 C( U) K2 I- m# F& f    }
0 Y" i( u, r/ ]  J9 D* k
! n7 Q' a9 V$ M/ [" R. J
. L3 Y" U$ H0 ^- {8 ~. I! g    if (flag) //如果满足条件了
4 [0 {( L: l5 _# w' @; k    {
& R6 K9 F0 \2 ^5 k) L, D1 N        /*动作执行*/
& T+ _+ e5 b# F6 v        if (eventActFun)
        {
            eventActFun();
        }

        //跳转到下一个状态
        fsmStateTransfer(pFsm, NextState);
9 H8 H5 W* t  T3 ]7 Z5 ?    }
2 N+ ?" i6 h* T    else
; T" Y2 h) g! C$ b    {
0 L$ Z/ [; N9 z        printf("there is no match\n");
    }
}
附代码

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

测试程序//编译器：http://www.dooccn.com/cpp/
% S$ U/ ?% Y5 w- c, U- z//来源：技术让梦想更伟大
# |6 y; `4 C: ^& l) n) e//作者：李肖遥
#include <stdio.h>
9 d& A' ]+ b5 U* D# T
3 ]  Z! a7 E: A! O1 t% Utypedef enum {
  state_1=1,
3 j+ `! R9 e) z  y4 [$ t( v  state_2,
  state_3,
* _5 B. F0 U& Z$ ?3 A: g  H/ H  state_4
}State;

# K/ C3 X! k1 D) X6 L  ^typedef enum{
2 ]; Q: Q$ |3 ?8 _4 s  V; z- k  event_1=1,
  event_2,
  event_3,
  event_4,
" l3 u0 b! ]$ H7 g: @  event_5
) w( W& q* S3 A}EventID;

typedef struct {
4 j; V1 c7 T& K, X- w    int event;   //事件
    int CurState;  //当前状态
    void (*eventActFun)();  //函数指针
$ A$ q! P2 C1 ?& C# m  y% w: ~    int NextState;  //下一个状态
6 ?: k* Q7 r4 m3 \1 Z2 A( g}StateTable;
" v0 y& c: M3 r9 W5 x0 W
2 z6 b1 ^% w3 o/ a" A4 Qvoid f121()
) T2 C# k2 g1 [{
    printf("this is f121\n");
}
void f221()
- y6 K+ ?* s' u1 ]! p: A2 ^: F{
, n0 c) U0 q* t    printf("this is f221\n");
}
0 d# Y: t, Z9 V3 @/ }1 |) A1 i$ [. bvoid f321()
8 c* I! d! U; b' M- n{
1 A: S( \5 a7 \9 J' ], U6 a    printf("this is f321\n");
}
* \0 f3 x" F  M5 e6 P
( Q8 H7 z: ?2 q& I. _# K* ?void f122()
{
, k, e. z% u; o$ x( M; Q! L    printf("this is f122\n");
}

% U+ Z6 e. F0 g2 L4 P* I& yStateTable fTable[] =
" r. Y0 A2 H; r! m6 H0 ^{
    //{到来的事件，当前的状态，将要要执行的函数，下一个状态}
    { event_1,  state_1,    f121,  event_2 },
    { event_2,  state_2,    f221,  event_3 },
    { event_3,  state_3,    f321,  event_4 },
    { event_4,  state_4,    f122,  event_1 },
9 w6 v) a  E$ g3 I    //add your code here
};
& Z6 \5 b/ \% G
; W/ ~) T" {% p/ T/*状态机类型*/
- E" @! c1 n# N7 o! Jtypedef struct {
    int curState;//当前状态
    StateTable * stateTable;//状态表
8 a7 z# H# J( q3 Z, R    int size;//表的项数
}fsmType;

/*状态机注册,给它一个状态表*/
void fsmRegist(fsmType* pFsm, StateTable* pTable)
{
    pFsm->stateTable = pTable;
}
' w. ^  ?# l% a/ K6 X4 t% u8 z$ s
/*状态迁移*/
void fsmStateTransfer(fsmType* pFsm, int state)
+ h5 n' l3 }% E' P: S{
4 p. S% o! V& L  _: Y3 ?( l# I6 f. h    pFsm->curState = state;
}

/*事件处理*/
void fsmEventHandle(fsmType* pFsm, int event)
{
6 B0 ^( `( ]( D, x    StateTable* pActTable = pFsm->stateTable;
    void (*eventActFun)() = NULL;  //函数指针初始化为空
; T  Z6 I! c4 S7 E    int NextState;
    int CurState = pFsm->curState;
9 I: r9 y+ y. n5 A4 H' R; B    int maxNum = pFsm->size;
/ [% N3 r! q8 I3 k( {* L    int flag = 0; //标识是否满足条件

    /*获取当前动作函数*/
    for (int i = 0; i<maxNum; i++)
4 z8 f! U2 U0 B, ~- U2 v    {
        //当且仅当当前状态下来个指定的事件，我才执行它
- G, n0 H* V7 A: i2 X% I( |1 P# n        if (event == pActTable.event && CurState == pActTable.CurState)
0 F6 }5 E- W2 v/ F  |3 R4 e        {
            flag = 1;
            eventActFun = pActTable.eventActFun;
) Y7 l8 W  K7 b% |# S8 W5 D+ _            NextState = pActTable.NextState;
0 x- ~6 s5 L4 N            break;
8 W/ f: \% I$ ?        }
    }
5 j0 [; N% K" Z$ J4 x

  O- p9 F) L# J8 Z+ X5 M0 M    if (flag) //如果满足条件了
/ b$ s0 Y7 n; i+ j. X/ T    {
5 [3 K* q3 F) x/ @* K        /*动作执行*/
# r# p+ k& b9 I+ X        if (eventActFun)
        {
, R; ]+ q% Y. m            eventActFun();
        }
; g7 a6 w7 A/ O7 @
4 w% Y) T0 l6 w. y( y. l+ Z        //跳转到下一个状态
        fsmStateTransfer(pFsm, NextState);
8 N0 `7 X/ u  o    }
    else
# S2 p& _1 J7 Q2 T& d    {
        printf("there is no match\n");
    }
* ^. P0 B" J1 w; a* q: k}
. r, L( l8 D1 t& D
int main()
: c% B+ o& w6 O  C9 `{
" @. r5 B# v$ ^, K6 T: ~# p    fsmType pType;
" B6 {9 e: u; P0 H2 ?3 @4 ^6 m    fsmRegist(&pType,fTable);
8 r- K) f7 _7 U/ \% G  p- s    pType.curState = state_1;
    pType.size = sizeof(fTable)/sizeof(StateTable);


  U3 n8 a" {: M4 [, H    printf("init state:%d\n\n",pType.curState);

8 R, a4 ^5 f/ C    fsmEventHandle(&pType,event_1);
    printf("state:%d\n\n",pType.curState);

) a; w* N, ^. w+ U5 E$ L+ {2 `    fsmEventHandle(&pType,event_2);
    printf("state:%d\n\n",pType.curState);

    fsmEventHandle(&pType,event_3);
    printf("state:%d\n\n",pType.curState);
, [$ c5 x  O* R" b  E' U! J
( s0 c- H8 _9 m4 f5 z    fsmEventHandle(&pType,event_4);
1 E5 Y& Z7 Z3 T, x4 K" i6 U    printf("state:%d\n\n",pType.curState);
* b) [( }1 B0 ?# j. P
    fsmEventHandle(&pType,event_2);
    printf("state:%d\n\n",pType.curState);
" q+ E7 f0 I( d3 s& e/ @
$ v+ ?' G2 t# U- N+ ?    return 0;
}
1 \: ~6 ^4 _5 ~* V0 p编译结果
, n. ?5 u5 [/ s: A3 r- {总结

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

% I/ ~2 c! a& ~% U5 ^7 e. I