blocks|key|1462015|text|这就是您需要知道的全部内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1462016|int+state+=+0;
while+(state+<+3)
{
++++switch+(state)
++++{
++++++++case+0:
++++++++++++//+Do+State+0+Stuff
++++++++++++if+(should_go_to_next_state)
++++++++++++{
++++++++++++++++state%2B%2B;
++++++++++++}
++++++++++++break;
++++++++case+1:
++++++++++++//+Do+State+1+Stuff++++
++++++++++++if+(should_go_back)+
++++++++++++{
++++++++++++++++state--;
++++++++++++}++++
++++++++++++else+if+(should_go_to_next_state)+
++++++++++++{
++++++++++++++++state%2B%2B;
++++++++++++}
++++++++++++break;
++++++++case+2:
++++++++++++//+Do+State+2+Stuff++++
++++++++++++if+(should_go_back_two)+
++++++++++++{
++++++++++++++++state+-=+2;
++++++++++++}++++
++++++++++++else+if+(should_go_to_next_state)+
++++++++++++{
++++++++++++++++state%2B%2B;
++++++++++++}
++++++++++++break;
++++++++default:
++++++++++++break;
++++}
}|code-block|syntax|javascript|1462017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is all you need to know.

<pre><code>int state = 0;
while (state &lt; 3)
{
 switch (state)
 {
 case 0:
 // Do State 0 Stuff
 if (should_go_to_next_state)
 {
 state++;
 }
 break;
 case 1:
 // Do State 1 Stuff 
 if (should_go_back) 
 {
 state--;
 } 
 else if (should_go_to_next_state) 
 {
 state++;
 }
 break;
 case 2:
 // Do State 2 Stuff 
 if (should_go_back_two) 
 {
 state -= 2;
 } 
 else if (should_go_to_next_state) 
 {
 state++;
 }
 break;
 default:
 break;
 }
}
</code></pre>

blocks|key|1462057|text|Real-Time+Object-Oriented+Modeling非常棒(出版于1994年，现在售价只有81美分，外加3.99美元的运费)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1462058|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0471599174^0|0|Y|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="https://rads.stackoverflow.com/amzn/click/com/0471599174" rel="nofollow noreferrer" rel="nofollow noreferrer">Real-Time Object-Oriented Modeling</a> was fantastic (published in 1994 and now selling for as little as 81 cents, plus $3.99 shipping).

blocks|key|1462125|text|状态机本身并不需要教程来解释或使用。我建议您查看一下数据以及如何对其进行解析。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1462126|例如，我必须解析Near+Space+balloon+flight+computer的数据协议，它以特定的格式(二进制)存储在SD卡上，需要解析成逗号分隔的文件。为此，使用状态机是最有意义的，因为根据下一位信息是什么，我们需要更改正在解析的内容。|offset|length|1462127|代码是使用C%2B%2B编写的，并且可以以ParseFCU的形式提供。正如您所看到的，它首先检测我们正在解析的版本，然后从那里进入两个不同的状态机。|1462128|它以已知良好的状态进入状态机，此时我们开始解析，根据我们遇到的字符，我们要么进入下一个状态，要么返回到前一个状态。这基本上允许代码自适应存储数据的方式，甚至是某些数据是否存在。|1462129|在我的示例中，GPS字符串不是飞行计算机进行日志记录所必需的，因此，如果找到单个日志写入的结束字节，则可以跳过对GPS字符串的处理。|1462130|状态机很容易编写，一般来说，我遵循它应该流动的规则。通过系统的输入应该能够从一个状态流转到另一个状态。|1462131|entityMap|0|LINK|mutability|MUTABLE|url|http://nearspace.0x58.com/index.php?title=Flight_Computer|1|http://nearspace.0x58.com/launches/Tools/ParseFCU.html^0|0|8|Y|0|0|H|8|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]|V|$5|Q|R|S|A|$T|W]]]]

State machines are not something that inherently needs a tutorial to be explained or even used. What I suggest is that you take a look at the data and how it needs to be parsed.

For example, I had to parse the data protocol for a <a href="http://nearspace.0x58.com/index.php?title=Flight_Computer" rel="noreferrer">Near Space balloon flight computer</a>, it stored data on the SD card in a specific format (binary) which needed to be parsed out into a comma seperated file. Using a state machine for this makes the most sense because depending on what the next bit of information is we need to change what we are parsing.

The code is written using C++, and is available as <a href="http://nearspace.0x58.com/launches/Tools/ParseFCU.html" rel="noreferrer">ParseFCU</a>. As you can see, it first detects what version we are parsing, and from there it enters two different state machines.

It enters the state machine in a known-good state, at that point we start parsing and depending on what characters we encounter we either move on to the next state, or go back to a previous state. This basically allows the code to self-adapt to the way the data is stored and whether or not certain data exists at all even.

In my example, the GPS string is not a requirement for the flight computer to log, so processing of the GPS string may be skipped over if the ending bytes for that single log write is found.

State machines are simple to write, and in general I follow the rule that it should flow. Input going through the system should flow with certain ease from state to state.

blocks|key|1462192|text|如果你使用函数指针，状态机在C中是非常简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1462193|基本上你需要两个数组-一个用于状态函数指针，一个用于状态转换规则。每个状态函数返回代码，您逐个状态查找状态转换表，并返回代码以找到下一个状态，然后执行它。|1462194|int+entry_state(void);
int+foo_state(void);
int+bar_state(void);
int+exit_state(void);

/*+array+and+enum+below+must+be+in+sync!+*/
int+(*+state[])(void)+=+{+entry_state,+foo_state,+bar_state,+exit_state};
enum+state_codes+{+entry,+foo,+bar,+end};

enum+ret_codes+{+ok,+fail,+repeat};
struct+transition+{
++++enum+state_codes+src_state;
++++enum+ret_codes+++ret_code;
++++enum+state_codes+dst_state;
};
/*+transitions+from+end+state+aren't+needed+*/
struct+transition+state_transitions[]+=+{
++++{entry,+ok,+++++foo},
++++{entry,+fail,+++end},
++++{foo,+++ok,+++++bar},
++++{foo,+++fail,+++end},
++++{foo,+++repeat,+foo},
++++{bar,+++ok,+++++end},
++++{bar,+++fail,+++end},
++++{bar,+++repeat,+foo}};

#define+EXIT_STATE+end
#define+ENTRY_STATE+entry

int+main(int+argc,+char+*argv[])+{
++++enum+state_codes+cur_state+=+ENTRY_STATE;
++++enum+ret_codes+rc;
++++int+(*+state_fun)(void);

++++for+(;;)+{
++++++++state_fun+=+state[cur_state];
++++++++rc+=+state_fun();
++++++++if+(EXIT_STATE+==+cur_state)
++++++++++++break;
++++++++cur_state+=+lookup_transitions(cur_state,+rc);
++++}

++++return+EXIT_SUCCESS;
}|code-block|syntax|javascript|1462195|我没有把lookup_transitions()函数放在那里，因为它很琐碎。|offset|length|style|CODE|1462196|这就是我多年来处理状态机的方式。|1462197|entityMap^0|0|0|0|4|K|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

State machines are very simple in C if you use function pointers.

Basically you need 2 arrays - one for state function pointers and one for state transition rules. Every state function returns the code, you lookup state transition table by state and return code to find the next state and then just execute it.

<pre><code>int entry_state(void);
int foo_state(void);
int bar_state(void);
int exit_state(void);

/* array and enum below must be in sync! */
int (* state[])(void) = { entry_state, foo_state, bar_state, exit_state};
enum state_codes { entry, foo, bar, end};

enum ret_codes { ok, fail, repeat};
struct transition {
 enum state_codes src_state;
 enum ret_codes ret_code;
 enum state_codes dst_state;
};
/* transitions from end state aren't needed */
struct transition state_transitions[] = {
 {entry, ok, foo},
 {entry, fail, end},
 {foo, ok, bar},
 {foo, fail, end},
 {foo, repeat, foo},
 {bar, ok, end},
 {bar, fail, end},
 {bar, repeat, foo}};

#define EXIT_STATE end
#define ENTRY_STATE entry

int main(int argc, char *argv[]) {
 enum state_codes cur_state = ENTRY_STATE;
 enum ret_codes rc;
 int (* state_fun)(void);

 for (;;) {
 state_fun = state[cur_state];
 rc = state_fun();
 if (EXIT_STATE == cur_state)
 break;
 cur_state = lookup_transitions(cur_state, rc);
 }

 return EXIT_SUCCESS;
}
</code></pre>

I don't put <code>lookup_transitions()</code> function as it is trivial.

That's the way I do state machines for years.

blocks|key|1462291|text|在C中学习手工制作状态机有很多教训，但我也建议使用Ragel状态机编译器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1462292|http://www.complang.org/ragel/|offset|length|1462293|它有非常简单的定义状态机的方法，然后你可以生成图形，生成不同风格的代码(表驱动，goto驱动)，如果你想分析代码，等等。它功能强大，可以用于各种协议的生产代码中。|1462294|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|U|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

There is a lot of lesson to learn handcrafting state machines in C, but let me also suggest Ragel state machine compiler:

<a href="http://www.complang.org/ragel/" rel="nofollow noreferrer">http://www.complang.org/ragel/</a>

It has quite simple way of defining state machines and then you can generate graphs, generate code in different styles (table-driven, goto-driven), analyze that code if you want to, etc. And it's powerful, can be used in production code for various protocols.

blocks|key|1462352|text|与庞大的switch语句相比，我更喜欢使用函数指针，但与qrdl's+answer相比，我通常不使用显式的返回码或转换表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1462353|此外，在大多数情况下，您需要一种机制来传递额外的数据。下面是一个状态机示例：|1462354|#include+<stdio.h>

struct+state;
typedef+void+state_fn(struct+state+*);

struct+state
{
++++state_fn+*+next;
++++int+i;+//+data
};

state_fn+foo,+bar;

void+foo(struct+state+*+state)
{
++++printf("%25s+%25i\n",+__func__,+%2B%2Bstate->i);
++++state->next+=+bar;
}

void+bar(struct+state+*+state)
{
++++printf("%25s+%25i\n",+__func__,+%2B%2Bstate->i);
++++state->next+=+state->i+<+10+?+foo+:+0;
}

int+main(void)
{
++++struct+state+state+=+{+foo,+0+};
++++while(state.next)+state.next(&state);
}|code-block|syntax|javascript|1462355|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1371460/state-machines-tutorials/1371654#1371654^0|4|6|S|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I prefer using function pointers over gigantic <code>switch</code> statements, but in contrast to <a href="https://stackoverflow.com/questions/1371460/state-machines-tutorials/1371654#1371654">qrdl's answer</a> I normally don't use explicit return codes or transition tables.

Also, in most cases you'll want a mechanism to pass along additional data. Here's an example state machine:

<pre><code>#include &lt;stdio.h&gt;

struct state;
typedef void state_fn(struct state *);

struct state
{
 state_fn * next;
 int i; // data
};

state_fn foo, bar;

void foo(struct state * state)
{
 printf("%s %i\n", __func__, ++state-&gt;i);
 state-&gt;next = bar;
}

void bar(struct state * state)
{
 printf("%s %i\n", __func__, ++state-&gt;i);
 state-&gt;next = state-&gt;i &lt; 10 ? foo : 0;
}

int main(void)
{
 struct state state = { foo, 0 };
 while(state.next) state.next(&amp;state);
}
</code></pre>

blocks|key|1247777|text|对于复杂的问题，状态机可能非常复杂。它们也会受到意想不到的bug的影响。如果有人在将来遇到bug或需要更改逻辑，它们可能会变成噩梦。如果没有状态图，它们也很难跟踪和调试。结构化编程要好得多(例如，您可能不会在主线级别使用状态机)。您甚至可以在中断上下文(通常使用状态机)中使用结构化编程。请参阅codeproject.com上的这篇文章"Macros+to+simulate+multi-tasking/blocking+code+at+interrupt+level"。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1247778|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/Articles/37037/Macros-to-simulate-multi-tasking-blocking-code-at^0|4O|1V|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

State machines can be very complex for a complex problem. They are also subject to unexpected bugs. They can turn into a nightmare if someone runs into a bug or needs to change the logic in the future. They are also difficult to follow and debug without the state diagram. Structured programming is much better (for example you would probably not use a state machine at mainline level). You can use structured programming even in interrupt context (which is where state machines are usually used). See this article <a href="http://www.codeproject.com/Articles/37037/Macros-to-simulate-multi-tasking-blocking-code-at" rel="nofollow">"Macros to simulate multi-tasking/blocking code at interrupt level"</a> found at codeproject.com.

I am just wondering if anyone know of some good tutorials on the Internet for developing state machines. Or ebooks?

I am starting working on state machines and just need something general to get me started.

state machines tutorials

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想知道在互联网上是否有人知道一些开发状态机的好教程。还是电子书？我开始在状态机上工作，只是需要一些通用的东西来开始。

问状态机教程
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机教程EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机教程
EN