一种有限状态机的C语言实现

状态机的原理就不说了，先给出状态机的转换图，很简单

实现的思路是这样的：

1、用函数指针表示状态（状态函数）。

2、状态函数接受一个参数（event），并根据event决定下一个状态。

3、状态函数返回一个函数指针，此函数指针的类型也是状态函数指针。即状态函数返回一个指向下一个状态函数的指针。

4、由于返回值是和原函数相同类型的函数指针，要定义成这样

typedef func_ptr_t (*func_ptr_t)(int);

   但是C语言中不允许这样定义一个函数指针。所以只能寻找变通的方法，这个方法就是强制类型转换。我们可以按照以下方式定义

typedef void (*func_ptr_ret_t)(int);
typedef func_ptr_ret_t (*func_ptr_t)(int);

   使用的时候进行强制类型转换,将返回值转换为func_ptr_t,这样就实现了一个能够返回与原函数相同类型函数指针的函数。

func_ptr_t func;
func_ptr_t func2; 
func = (func_ptr_t)func2(参数);

   知道了这些后，就可以写一个简单的状态机了。

// 定义函数指针类型
typedef void (*state_ret)(int event);
typedef state_ret (*state)(int event);

// 申明状态函数
state_ret STATE1(int event);
state_ret STATE2(int event);
state_ret STATE3(int event);

// 事件列表
enum EVENT_NUM{
  EVENT1,
  EVENT2,
  EVENT3,
  EVENT4,
};

int main(void)
{
  int event;
  int i = 0;
  
  // 初始状态设置为STATE1
  state curState;
  curState = STATE1;
  while(1){
    
    // 每次循环改变一次event值，实际中一般由外部事件驱动
    switch(i%5){
      case 0: event = EVENT1; break;
      case 1: event = EVENT2; break;
      case 2: event = EVENT3; break;
      case 3: event = EVENT4; break;
      case 4: event = EVENT2; break;
      default: break;
    }

    // 运行当前状态函数，返回下一状态函数指针，并保存起来
    curState = (state)curState(event);
    i++;
  }
  return 0;
}

// 状态1函数的实现
state_ret STATE1(int event)
{
  // 设置当前状态
  state_ret curState = (state_ret)STATE1;

  // 根据event确定下一状态
  switch(event){
    case EVENT1: curState = (state_ret)STATE2; break;
    case EVENT3: curState = (state_ret)STATE3; break;
    default: break;
  }

  // 返回下一状态函数指针
  return curState;
}

// 状态2函数实现
state_ret STATE2(int event)
{
  state_ret curState = (state_ret)STATE2;
  switch(event){
    case EVENT2: curState = (state_ret)STATE1; break;
    default: break;
  }
  return curState;
}

// 状态3函数实现
state_ret STATE3(int event)
{
  state_ret curState = (state_ret)STATE3;
  switch(event){
    case EVENT4: curState = (state_ret)STATE2; break;
    default: break;
  }
  return curState;
}