C语言实现状态机（二）

已于 2022-01-25 15:20:58 修改
阅读量6.9k 收藏 162
点赞数 28
分类专栏： fsm 文章标签： c语言 开发语言 后端
于 2022-01-23 17:16:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36969264/article/details/122365696
版权

前言

对于之前的一篇博客《C语言实现状态机》（链接：https://blog.csdn.net/qq_36969264/article/details/105865099?spm=1001.2014.3001.5501），看网友的留言，似乎对pFsm->stNextState 和 EVENT_MAP_END的比较有一些误解。
这里需要解释一下，当时这么写是为了省事，但后面看这么写确实很容易让人误解，所以这篇文章的目的是为了修改掉这个容易让人误解的地方，同时对该状态机做了一些优化。

一、实现状态机的基本函数

1、定义相关结构体

typedef void (*STATE_ACTION)(void);	

typedef struct ACTION_MAP
{
	uint8_t 		stStateID;
	STATE_ACTION 	EnterAct;	
	STATE_ACTION 	RunningAct;	
	STATE_ACTION 	ExitAct;
}ACTION_MAP_t; /* 动作action表描述 */

typedef struct EVENT_MAP
{
	uint8_t	stEventID;
	uint8_t stCurState;
	uint8_t stNextState;
}EVENT_MAP_t; /* 事件event表描述 */

typedef struct FSM
{
	uint8_t u8Flag; 			/* 状态切换标志位,1表示要进行状态切换 */
	uint8_t u8EventSum;			/* 事件event总数 */
	uint8_t u8ActSum;			/* 动作action总数 */
	uint8_t stCurState;
	uint8_t stNextState;
	ACTION_MAP_t *pActionMap;
	EVENT_MAP_t *pEventMap;
}FSM_t; /* 状态机控制结构 */

注：状态机控制结构FSM_t的元素u8Flag用于替代pFsm->stNextState 和 EVENT_MAP_END的比较，以实现相同的功能。

2、状态机初始化函数

初始化函数主要目的是为了将状态机与事件表、动作表关联起来。

void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState)
{
	pFsm->u8Flag = 0;
	pFsm->stNextState = 0;
	pFsm->u8EventSum = u8EventSum;
	pFsm->u8ActSum = u8ActSum;
	pFsm->stCurState = curState;
	pFsm->pEventMap = pEventMap;
	pFsm->pActionMap = pActionMap;
}

3、状态机转换函数

该函数的主要功能是通过查找事件表，以确定是否要进行状态切换，如果需要进行状态切换，则将标志位u8Flag 置1。

void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID)
{
	uint8_t i = 0;
	
	for(i=0; i<pFsm->u8EventSum; i++)
	{
		if((stEventID == pFsm->pEventMap[i].stEventID) 
			&& (pFsm->stCurState == pFsm->pEventMap[i].stCurState))
		{
			pFsm->stNextState = pFsm->pEventMap[i].stNextState;
			pFsm->u8Flag = 1;
			
			return;
		}
	}	
}

4、状态机动作执行函数

该函数为此状态机的精髓所在，一般的状态机在状态切换时只执行一次动作，或者周期执行同一动作。
而此状态机则在状态切换时执行当前动作的退出函数（一次），即ExitAct函数，实际应用当中可对该状态的一些变量进行清0，或者打印相关调试信息等；同时还会执行下一个状态的进入函数（一次），即EnterAct函数，实际应用当中可以对该状态的变量进行初始化等操作。在状态切换完成后，还会周期执行RunningAct函数。
这里的ExitAct函数和EnterAct函数类似于C++的构造函数和析构函数。

uint8_t get_action_sum(FSM_t* pFsm,uint8_t u8ID)
{
	int i = 0;
	
	for(i=0; i<pFsm->u8ActSum; i++)
	{
		if(u8ID == pFsm->pActionMap[i].stStateID)
			return i;
	}

	return -1;
}


void action_perfrom(FSM_t* pFsm)
{
	uint8_t u8CurID = -1, u8NextID = -1;
	
	if(0 != pFsm->u8Flag)	/* 标志位不为0表示要进行状态切换 */
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		u8NextID = get_action_sum(pFsm,pFsm->stNextState);
		
		if((-1 != u8CurID) && (-1 != u8NextID))
		{
			pFsm->pActionMap[u8CurID].ExitAct();	/* 执行当前状态的退出动作 */
			pFsm->pActionMap[u8NextID].EnterAct(); /* 执行下一个状态的进入动作 */
		}
		else
		{
			pFsm->u8Flag = 0;								/* 清标志位 */
			printf("State transition failed! curState = %d, nextState = %d\n",pFsm->stCurState,pFsm->stNextState);
			return;
		}
	
		pFsm->stCurState = pFsm->stNextState;			/* 当前状态切换 */
		pFsm->stNextState = -1;
		pFsm->u8Flag = 0;								/* 清标志位 */
	}
	else
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		if(-1 != u8CurID)
			pFsm->pActionMap[u8CurID].RunningAct();/* 标志位为0不进行状态切换，执行当前状态的do动作 */
	}	
}

二、如何使用状态机

这里还是使用之前的博客里状态机流程图为例：

在这里插入图片描述

1、以流程图为标准定义事件表

数组eventMap就是对以上流程图的全部描述：

#define EVENT1 0
#define EVENT2 1
#define EVENT3 2
#define EVENT4 3
#define EVENT5 4

EVENT_MAP_t eventMap[] = 
{
	{EVENT1,	STATE1,	STATE2},
	{EVENT2,	STATE2,	STATE3},	
	{EVENT3,	STATE3,	STATE4},
	{EVENT4,	STATE4,	STATE1},
	{EVENT5,	STATE1,	STATE4},	
};

2、定义动作表

#define STATE1 0
#define STATE2 1
#define STATE3 2
#define STATE4 3

ACTION_MAP_t actionMap[] = 
{
	{STATE1,	state1_entry,	state1_do,	state1_exit},
	{STATE2,	state2_entry,	state2_do,	state2_exit},
	{STATE3,	state3_entry,	state3_do,	state3_exit},
	{STATE4,	state4_entry,	state4_do,	state4_exit},
};

3、实现动作函数

这里的每个函数的内容可以根据实际情况进行填充。


void state1_entry(void)
{
	printf("state1_entry\n");
}
void state1_do(void)
{
	printf("state1_do\n");
}
void state1_exit(void)
{
	printf("state1_exit\n");
}

void state2_entry(void)
{
	printf("state2_entry\n");
}
void state2_do(void)
{
	printf("state2_do\n");
}
void state2_exit(void)
{
	printf("state2_exit\n");
}

void state3_entry(void)
{
	printf("state3_entry\n");
}
void state3_do(void)
{
	printf("state3_do\n");
}
void state3_exit(void)
{
	printf("state3_exit\n");
}

void state4_entry(void)
{
	printf("state4_entry\n");
}
void state4_do(void)
{
	printf("state4_do\n");
}
void state4_exit(void)
{
	printf("state4_exit\n");
}

4、实现表获取函数

/* 获取动作表 */
ACTION_MAP_t* get_action_map(uint8_t *total)
{
	*total = sizeof(actionMap)/sizeof(ACTION_MAP_t);
	return actionMap;
}

/* 获取事件表 */
EVENT_MAP_t* get_event_map(uint8_t *total)
{
	*total = sizeof(eventMap)/sizeof(EVENT_MAP_t);
	return eventMap;
}

5、测试

int main(void)
{
	int i = 0;		
	uint8_t u8ActNum = 0, u8EventNum = 0;
	FSM_t stFsm;	/* 定义状态机 */
	ACTION_MAP_t* stActMap;
	EVENT_MAP_t* stEventMap;
	
	stActMap = get_action_map(&u8ActNum);
	stEventMap = get_event_map(&u8EventNum);
	
	fsm_init(&stFsm,stEventMap,stActMap,u8EventNum,u8ActNum,STATE1);
	while(1)
	{
		sleep(1);
		printf("i = %d\n",i++);
		
		action_perfrom(&stFsm);
		
		/* 利用i产生EVENT1~EVENT5 */
		if(1 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT1);
		}
		
		if(3 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT2);
		}
		
		if(5 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT3);
		}
		
		if(7 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT4);
		}	
		
		if(9 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT5);
		}
	}
	return 0;
}

调试信息如下：
在这里插入图片描述

三、附上代码

fsm.c

#include <stdio.h>
#include "fsm.h"

void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState)
{
	pFsm->u8Flag = 0;
	pFsm->stNextState = 0;
	pFsm->u8EventSum = u8EventSum;
	pFsm->u8ActSum = u8ActSum;
	pFsm->stCurState = curState;
	pFsm->pEventMap = pEventMap;
	pFsm->pActionMap = pActionMap;
}

void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID)
{
	uint8_t i = 0;
	
	for(i=0; i<pFsm->u8EventSum; i++)
	{
		if((stEventID == pFsm->pEventMap[i].stEventID) 
			&& (pFsm->stCurState == pFsm->pEventMap[i].stCurState))
		{
			pFsm->stNextState = pFsm->pEventMap[i].stNextState;
			pFsm->u8Flag = 1;
			
			return;
		}
	}	
}

uint8_t get_action_sum(FSM_t* pFsm,uint8_t u8ID)
{
	int i = 0;
	
	for(i=0; i<pFsm->u8ActSum; i++)
	{
		if(u8ID == pFsm->pActionMap[i].stStateID)
			return i;
	}

	return -1;
}

void action_perfrom(FSM_t* pFsm)
{
	uint8_t u8CurID = -1, u8NextID = -1;
	
	if(0 != pFsm->u8Flag)	/* 标志位不为0表示要进行状态切换 */
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		u8NextID = get_action_sum(pFsm,pFsm->stNextState);
		
		if((-1 != u8CurID) && (-1 != u8NextID))
		{
			pFsm->pActionMap[u8CurID].ExitAct();	/* 执行当前状态的退出动作 */
			pFsm->pActionMap[u8NextID].EnterAct(); /* 执行下一个状态的进入动作 */
		}
		else
		{
			pFsm->u8Flag = 0;								/* 清标志位 */
			printf("State transition failed! curState = %d, nextState = %d\n",pFsm->stCurState,pFsm->stNextState);
			return;
		}
	
		pFsm->stCurState = pFsm->stNextState;			/* 当前状态切换 */
		pFsm->stNextState = -1;
		pFsm->u8Flag = 0;								/* 清标志位 */
	}
	else
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		if(-1 != u8CurID)
			pFsm->pActionMap[u8CurID].RunningAct();/* 标志位为0不进行状态切换，执行当前状态的do动作 */
	}	
}

fsm.h

#ifndef FSM_H
#define FSM_H

#include "common.h"

typedef void (*STATE_ACTION)(void);	

typedef struct ACTION_MAP
{
	uint8_t 		stStateID;
	STATE_ACTION 	EnterAct;	
	STATE_ACTION 	RunningAct;	
	STATE_ACTION 	ExitAct;
}ACTION_MAP_t; /* 动作action表描述 */

typedef struct EVENT_MAP
{
	uint8_t	stEventID;
	uint8_t stCurState;
	uint8_t stNextState;
}EVENT_MAP_t; /* 事件event表描述 */

typedef struct FSM
{
	uint8_t u8Flag; 			/* 状态切换标志位,1表示要进行状态切换 */
	uint8_t u8EventSum;			/* 事件event总数 */
	uint8_t u8ActSum;			/* 动作action总数 */
	uint8_t stCurState;
	uint8_t stNextState;
	ACTION_MAP_t *pActionMap;
	EVENT_MAP_t *pEventMap;
}FSM_t; /* 状态机控制结构 */


void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState);
void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID);
void action_perfrom(FSM_t* pFsm);

#endif

action.c

#include <stdio.h>
#include "action.h"

void state1_entry(void);
void state1_do(void);
void state1_exit(void);
void state2_entry(void);
void state2_do(void);
void state2_exit(void);
void state3_entry(void);
void state3_do(void);
void state3_exit(void);
void state4_entry(void);
void state4_do(void);
void state4_exit(void);


ACTION_MAP_t actionMap[] = 
{
	{STATE1,	state1_entry,	state1_do,	state1_exit},
	{STATE2,	state2_entry,	state2_do,	state2_exit},
	{STATE3,	state3_entry,	state3_do,	state3_exit},
	{STATE4,	state4_entry,	state4_do,	state4_exit},
};
void state1_entry(void)
{
	printf("state1_entry\n");
}
void state1_do(void)
{
	printf("state1_do\n");
}
void state1_exit(void)
{
	printf("state1_exit\n");
}

void state2_entry(void)
{
	printf("state2_entry\n");
}
void state2_do(void)
{
	printf("state2_do\n");
}
void state2_exit(void)
{
	printf("state2_exit\n");
}

void state3_entry(void)
{
	printf("state3_entry\n");
}
void state3_do(void)
{
	printf("state3_do\n");
}
void state3_exit(void)
{
	printf("state3_exit\n");
}

void state4_entry(void)
{
	printf("state4_entry\n");
}
void state4_do(void)
{
	printf("state4_do\n");
}
void state4_exit(void)
{
	printf("state4_exit\n");
}

ACTION_MAP_t* get_action_map(uint8_t *total)
{
	*total = sizeof(actionMap)/sizeof(ACTION_MAP_t);
	return actionMap;
}

action.h

#ifndef ACTION_H
#define ACTION_H

#include "common.h"
#include "fsm.h"

#define STATE1 0
#define STATE2 1
#define STATE3 2
#define STATE4 3

ACTION_MAP_t* get_action_map(uint8_t *total);

#endif

event.c

#include "event.h"

EVENT_MAP_t eventMap[] = 
{
	{EVENT1,	STATE1,	STATE2},
	{EVENT2,	STATE2,	STATE3},	
	{EVENT3,	STATE3,	STATE4},
	{EVENT4,	STATE4,	STATE1},
	{EVENT5,	STATE1,	STATE4},	
};

EVENT_MAP_t* get_event_map(uint8_t *total)
{
	*total = sizeof(eventMap)/sizeof(EVENT_MAP_t);
	return eventMap;
}

event.h

#ifndef EVENT_H
#define EVENT_H

#include "fsm.h"
#include "common.h"
#include "action.h"

#define EVENT1 0
#define EVENT2 1
#define EVENT3 2
#define EVENT4 3
#define EVENT5 4

EVENT_MAP_t* get_event_map(uint8_t* total);

#endif

common.h

#ifndef COMMON_H
#define COMMON_H

typedef  unsigned char uint8_t;


#endif

main.c

int main(void)
{
	int i = 0;		
	uint8_t u8ActNum = 0, u8EventNum = 0;
	FSM_t stFsm;	/* 定义状态机 */
	ACTION_MAP_t* stActMap;
	EVENT_MAP_t* stEventMap;
	
	stActMap = get_action_map(&u8ActNum);
	stEventMap = get_event_map(&u8EventNum);
	
	fsm_init(&stFsm,stEventMap,stActMap,u8EventNum,u8ActNum,STATE1);
	while(1)
	{
		sleep(1);
		printf("i = %d\n",i++);
		
		action_perfrom(&stFsm);
		
		/* 利用i产生EVENT1~EVENT5 */
		if(1 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT1);
		}
		
		if(3 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT2);
		}
		
		if(5 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT3);
		}
		
		if(7 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT4);
		}	
		
		if(9 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT5);
		}
	}
	return 0;
}

Makefile

objects = fsm.o action.o event.o

main:*.o
	cc -o $@ $^

*.o:*.c 
	cc -c $^

clean:
	rm *.o -rf
	rm main -rf
qq_36969264
关注
  • 28
    点赞
  • 踩
  • 162
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
高级C语言-链表&状态机和多线程
qq_52916060的博客
12-10 766
单链表&双向链表&多线程引入&状态机是什么？
C语言实现有限状态机
12-22
有限状态机是一种数学概念，运用到程序中，可用于有限数量的状态的变化，每个子程序进行一些处理并选择下一种状态。 　　基本的实现思路是用一张表保存所有可能的状态，并列出进入每个状态时可能执行的所有动作，其中后一个动作是计算下一个应该进入的状态。运行状态是从初始状态开始，不停的在各个状态之间转换，直到结束状态。 　　FSM的实现方式： 　　1）switch/case或者if/else 　　这无意是直观的方式，使用一堆条件判断，会编程的人都可以做到，对简单小巧的状态机来说合适，但是毫无疑问，这样的方式比较原始，对庞大的状态机难以维护。 　　2）状态表 　　维护一个二维状态表，横
一种轻量级的函数指针状态机框架--EFSM
chenbb8的专栏
09-26 1476
本文介绍了一个轻量级的函数指针状态机编程框架EFSM（Extended Finite State Machin--扩展有限状态机），适用于嵌入式环境，相对普通的FSM扩展出了进入/离开动作。
C++学习进阶版（一）：用C++写简单的状态机实现
最新发布
共同学习，共同进步。
04-17 1904
状态机基础知识，并使用C++写学生日常生活的状态机实现。
用C语言实现状态机设计模式
weixin_43947512的博客
07-29 938
举个例子task1(BSM,condition1/action1–>NOS)和task2(NOS,condition2/action2–>RSS)先后执行，是可以顺利到达RSS状态的，但若操作action1运行的时候，执行权限被task2抢占，则task2此时看到的当前状态还是BSM，BSM遇到condition2就进入陷阱状态，而不会到达RSS了，也就是说，状态的跳转发生了不确定，这是不能容忍的。当某个状态遇到不能识别的输入时，就默认进入陷阱状态，在陷阱状态中，不论遇到怎样的输入都不能跳出。...
＜C语言＞C语言实现状态机
lhwq26的博客
11-19 829
ch2 C语言实现状态机 ​ 状态机模式适用于有限状态下程序按照逻辑循环执行，相较于在while循环中通过if else判断状态标志来执行相应的动作，状态机模式能够灵活的增加、减少状态，程序逻辑更为清晰 ​ 使用函数指针管理状态，每个状态执行函数在执行完之后，返回下一个状态执行函数的指针，判断state进而执行程序 //函数指针重定义 typedef int (*functpr)(); //函数指针类型转换声明 typedef functpr (*ptrfuncptr)(); //定义起始状态、停止状态、状
操作系统：进程状态转换模拟，C语言实现
weixin_45038876的博客
10-02 3777
编写并调试一个模拟的进程调度和进程状态转换过程，采用“基于时间片轮转法”调度算法对N（N不小于5）个进程进行调度。要求使用C/C++编程实现（如有难度也可酌情使用Java或C#实现）。首先绘制流程图，然后将程序源代码和运行效果放入实验报告中。 简单轮转法的基本思想是：所有就绪进程按先来先服务的方式排成一个队列，总是把处理机分配给队头的进程，各进程占用CPU的时间片长度相同（如1个CPU时间单位）。当把处理机分配给队头的进程后，该进程出就绪队列，并将进程状态从就绪态变化为运行态。如果运行进程用完它的时间片后还
C程序设计：状态机
weixin_42549534的博客
07-31 747
状态机是一种常用的编程模型，用于描述系统的状态和状态之间的转换规则。无论使用何种操作系统或编程框架，状态机都可以用来帮助设计和实现系统的逻辑。即使在使用 FreeRTOS 的情况下，如果系统的逻辑需要描述为多个状态和状态转换，那么状态机仍然是一种很有用的设计工具。在上面的例子中，有两个状态 S1 和 S2，输入有两个选项 A 和 B，输出有四个选项 O1、O2、O3 和 O4。根据当前状态和输入，状态机会根据表格的规则进行状态转移，并输出相应的结果。
C语言嵌入式状态机架构（含C源码）
05-29
在C语言中，实现状态机通常采用函数指针的方式。这是因为函数指针可以被视为指向执行特定任务的代码的指针，使得我们可以在运行时动态地调用不同的函数，对应于不同的状态行为。以下是一个简单的步骤，展示了如何...
C语言实现状态机解析单词
11-15
C++的多态，本质上和在C语言当中的函数指针一样，通过一种手段，调用不同的函数，实现对同一事物实现不同的处理方式。最近在写一个单词解析的练习题，刚好是使用了函数指针来达到隔离变化，降低耦合的目的，本文将是...
c语言实现状态机.zip
02-28
以下是对C语言实现状态机相关知识点的详细说明： 1. **状态机基础概念**： 状态机是一个抽象的概念，它描述了一个实体在不同时间可能处于的不同状态以及这些状态之间的转换。状态机可以分为有限状态机（FSM）和...
状态机知识 状态机c语言实现
05-14
限状态机（Finite State Machine或者Finite State Automata)是软件领域中一种重要的工具，很多东西的模型实际上就是有限状态机。
状态机的C语言编程
11-09
有限状态机的实现方式、状态机的两种写法+实例、有限状态机自动机
有限状态机的c语言实现
10-26
#include int main() { int state_key = 1; //钥匙状态 为1时钥匙区有钥匙，为时钥匙区 无钥匙 int state_hold = 0; // 钥匙持有状态 为1时持有钥匙，为时 未持有钥匙 int state_door = 0; //门状态 0:关闭 1:打开 int state_lock = 1; //上锁状态 1:上锁 0:解锁 int order; // 用于存放用户输入指令 printf("this is a game.\n"); printf ("if you want to OPEN THE DOOR ,input 1\n"); printf ("if you want to CLOSE THE DOOR ,input 2\n"); printf ("if you want to LOCK THE DOOR ,input 3\n"); printf ("if you want to UNLOCK THE DOOR,input 4\n"); // printf ("if you want to LOCK THE DOOR ,input 5\n"); printf("please input the order\n"); while(1) { scanf("%d",&order); // if(order!=(1||2||3||4)) // { // printf("worng input ,please input again.\n"); // continue; // } switch(order) { case 1 : if(state_door==1) { printf("the door has been opened before\n"); break; } if(state_lock==1) { printf("the door has been lock\n"); break; } state_door=1; break; case 2: if(state_door==0) { printf("the door has been closed before\n"); break; } if(state_lock==1) { printf("the door has been lock\n"); break; } state_door=0; break; case 3: if(state_door==1) { printf("the door has been opened before\n"); break; } if(state_lock==1) { printf("the door has been lock\n"); break; } state_lock=1; break ; case 4: if(state_door==1) { printf("the door has been opened before\n"); break; } if(state_lock==0) { printf("the door has not been lock\n"); break; } state_lock=0; break ; } } }
c语言设计模式代码完整实现-状态机模式
jenie的专栏
06-01 6448
模式介绍 状态（state）模式是C语言实现相当常用的模式，也是能够在C语言***现出来的最显性的模式之一。在面向对象里，状态模式允许一个对象在内部状态改变的时候改变其行为。 状态用法很多，最常见的是状态机，分为无限状态机和有限状态机。 有限状态机finite-state machine，FSM，输入集合和输出集合都是有限的，并只有有限数目的状态。一般说到状态机即是对有限状态机的简称。 无限状态机infinite-state machine，ISM，输入和输出集合无线，状态数目无限的状态...
[C/C++]状态机
小蜗牛之家
09-19 2061
方法： 1.用于接收事件，并根据事件类型到相关的表中分配处理函数 所以只需要把事件类型（通常是消息），传入状态机进行分配即可 2.通常只是读取的一些操作，不涉及更改的，只是读取显示的，都放在预处理中处理（就是和状态无关） 3.状态机编程的一些基础原则： 1.除了到初始化状态和退出状态，其他所有的状态，之前的迁移，必须保证每个状态有且仅有一个消息能够使得状态发生转移所以画状态转移图的时候...
层次状态机的实现 c语言
xiaojuliet的专栏
06-24 3695
层次状态机的实现 2006-03-14 15:56:47 分类：   本文讲述层次状态机实现形式中的行为继承。从行为继承与类继承之间的OO类相似来看，一个成功的层次状态机应该能够模拟下列属于C++对象模型。 ²        使用和维护简单 ²        应允许转态机拓扑容易改变，不应要求转换连接的人工代码，所需要的修改限制在代码的一个地方。 ²        
基于C语言的最优HSM状态机架构实现
小鱼儿飞丫飞
06-20 3275
一、双层状态机框架 该状态机有两个父类状态机（可自由添加更多父类状态机） 每个父类状态机内部有若干个子状态机（可自由添加更多子类状态机） 二、直接上代码 /**************************************************************************** 作者：小鱼儿飞丫飞 日期：2020-6-19 文件名：FSM层次状态机头文件 *************************************************************
C语言高级篇 - 4.链表&状态机与多线程
poi_carefree的博客
09-18 753
1.链表的引入 1、从数组的缺陷说起         (1)数组有2个缺陷，一个是数组中所有元素的类型必须一致；第二个是数组的元素个数必须事先制定并且一旦指定之后不能更改。         (2)如何解决数组的2个缺陷：数组的第一个缺陷靠结构体去解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。所以说结构体是因为数组不能解决某些问题所以才发明的。         (3)如...
用c语言实现状态机代码
07-08
以下是一个使用C语言实现的简单状态机代码示例： ```c #include // 状态枚举 typedef enum { STATE_A, STATE_B, STATE_C } State; // 事件枚举 typedef enum { EVENT_1, EVENT_2, EVENT_3 } Event; // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值