怎么在程序里面实现状态机呢

zjia2

老是听一些高人提状态机，状态机有甚么用处，有甚么好处， 状态机和异步模式有甚么关系， 总之是好多问题困扰着我。

如果哪位大哥有现成的code，展示一些甚么是状态机，在程序中如何实现，那就真是不胜感激了

[ 本帖最后由 zjia2 于 2006-9-6 16:32 编辑 ]

isjfk

状态机...随便找一本离散数学、算法之类的书里面就有。

下面的是一个简单的状态机，作用是解析 Oracle 一个备份程序输出的信息，判断备份是否成功。

1. 
   
2. /**
   
3. * A state machine to determine whether db backup success.
   
4. */
   
5. class StateMachine {
   
6. private:
   
7.         // state machine states
   
8.         enum {
   
9.                 SM_NORMAL,                        // in backup
   
10.                 SM_NEW_LINE,                // new line begin
    
11.                 SM_CHAR_EXPECTED,        // expect an character (error condition is about to start)
    
12.                 SM_BAR_EXPECTED,        // expect a '-'
    
13.                 SM_NUM_EXPECTED,        // expect a number
    
14.                 SM_COLON_EXPECTED,        // expect a ':'
    
15.         };
    
16.         bool backupStart;
    
17.         bool error;                                // error occure
    
18.         int errorState;                        // error state
    
19.         int state;                                // state machine state
    
20. 
    
21.         int charNum;                        // number of char readed in error condition
    
22.         int digitNum;                        // number of digit readed in error condition
    
23.         std::string errMsg;                // error message
    
24. 
    
25. public:
    
26.         // error states
    
27.         enum {
    
28.                 OB_OK = 0,
    
29. 
    
30.                 EXP_ERROR,                                // unclassified client error
    
31.                 EXP_ID_ERROR,                        // client error: invalid user name and/or password
    
32. 
    
33.                 ORA_ERROR,                                // unclassified oracle error
    
34.                 ORA_ID_ERROR,                        // user name and password error
    
35.                 ORA_NO_CONNECTION,                // no network adapter
    
36.                 ORA_CONNECTION_TIMEOUT,        // can't make connection to host
    
37.                 ORA_CONNECTION_BROKEN,        // network connection broken
    
38.         };
    
39. 
    
40.         StateMachine(void)
    
41.                 : error(true)
    
42.                 , errorState(OB_OK)
    
43.                 , backupStart(false)
    
44.                 , state(SM_NORMAL)
    
45.                 , charNum(0)
    
46.                 , digitNum(0)
    
47.         {
    
48.         }
    
49. 
    
50.         int parse(int c) {
    
51.                 switch (state) {
    
52.                 case SM_NORMAL:
    
53.                         if (c == '\n')
    
54.                                 state = SM_NEW_LINE;
    
55.                         break;
    
56. 
    
57.                 case SM_NEW_LINE:
    
58.                         if (c == '.') {
    
59.                                 state = SM_NORMAL;
    
60. 
    
61.                                 error = true;
    
62.                                 backupStart = true;
    
63.                         } else if ((c != ' ') && (c != '\t')) {
    
64.                                 if (isalpha(c)) {
    
65.                                         state = SM_CHAR_EXPECTED;        // an error is about to occur
    
66. 
    
67.                                         errMsg = "";
    
68.                                         errMsg += c;
    
69.                                         charNum = 1;
    
70.                                         digitNum = 0;
    
71.                                 } else {                                                // ignore other character
    
72.                                         state = SM_NORMAL;
    
73.                                 }
    
74. 
    
75.                                 if (backupStart) {
    
76.                                         // if backup started and no error occured,
    
77.                                         // this maybe a successful message.
    
78.                                         if (errorState == OB_OK) {
    
79.                                                 error = false;
    
80.                                         }
    
81.                                 } else {
    
82.                                         error = true;
    
83.                                 }
    
84.                         }
    
85.                         break;
    
86. 
    
87.                 case SM_CHAR_EXPECTED:
    
88.                         if (isalpha(c)) {
    
89.                                 errMsg += c;
    
90.                                 ++charNum;
    
91.                                 if (charNum == 3) {
    
92.                                         state = SM_BAR_EXPECTED;
    
93.                                 }
    
94.                         } else {
    
95.                                 state = SM_NORMAL;
    
96.                         }
    
97.                         break;
    
98. 
    
99.                 case SM_BAR_EXPECTED:
    
100.                         if (c == '-') {
     
101.                                 errMsg += c;
     
102.                                 state = SM_NUM_EXPECTED;
     
103.                                 if (errMsg == "EXP-") {
     
104.                                         errorState = EXP_ERROR;
     
105.                                 } else if (errMsg == "ORA-") {
     
106.                                         errorState = ORA_ERROR;
     
107.                                 } else {
     
108.                                         state = SM_NORMAL;
     
109.                                 }
     
110.                         } else {
     
111.                                 state = SM_NORMAL;
     
112.                         }
     
113.                         break;
     
114. 
     
115.                 case SM_NUM_EXPECTED:
     
116.                         if (isdigit(c)) {
     
117.                                 errMsg += c;
     
118.                                 ++digitNum;
     
119.                                 if (digitNum == 5) {                        // error detected
     
120.                                         state = SM_COLON_EXPECTED;
     
121.                                 }
     
122.                         } else {                                                // not an error message
     
123.                                 state = SM_NORMAL;
     
124.                                 errorState = OB_OK;
     
125.                         }
     
126.                         break;
     
127. 
     
128.                 case SM_COLON_EXPECTED:
     
129.                         if (c == ':') {
     
130.                                 state = SM_NORMAL;
     
131. 
     
132.                                 error = true;
     
133. 
     
134.                                 switch (errorState) {
     
135.                                 case EXP_ERROR:
     
136.                                         if (errMsg == "EXP-00004") {
     
137.                                                 errorState = EXP_ID_ERROR;
     
138.                                                 return EXP_ID_ERROR;
     
139.                                         }
     
140.                                         return EXP_ERROR;
     
141.                                         break;
     
142. 
     
143.                                 case ORA_ERROR:
     
144.                                         if (errMsg == "ORA-01017") {
     
145.                                                 errorState = ORA_ID_ERROR;
     
146.                                                 return ORA_ID_ERROR;
     
147.                                         } else if ((errMsg == "ORA-03113")
     
148.                                                         || (errMsg == "ORA-03114")) {
     
149.                                                 errorState = ORA_CONNECTION_BROKEN;
     
150.                                                 return ORA_CONNECTION_BROKEN;
     
151.                                         } else if ((errMsg == "ORA-12535")
     
152.                                                         || (errMsg == "ORA-12170")) {
     
153.                                                 errorState = ORA_CONNECTION_TIMEOUT;
     
154.                                                 return ORA_CONNECTION_TIMEOUT;
     
155.                                         } else if (errMsg == "ORA-12560") {
     
156.                                                 errorState = ORA_NO_CONNECTION;
     
157.                                                 return ORA_NO_CONNECTION;
     
158.                                         }
     
159.                                         return ORA_ERROR;
     
160.                                         break;
     
161.                                 }
     
162.                         } else {
     
163.                                 state = SM_NORMAL;
     
164.                                 errorState = OB_OK;
     
165.                         }
     
166.                         break;
     
167. 
     
168.                 default:
     
169.                         state = SM_NORMAL;
     
170.                         break;
     
171.                 }
     
172. 
     
173.                 return OB_OK;
     
174.         }
     
175. 
     
176.         void reset(void) {
     
177.                 state = SM_NORMAL;
     
178.                 error = true;
     
179.         }
     
180. 
     
181.         int getState(void) {
     
182.                 if (error)
     
183.                         return -1;
     
184.                 else
     
185.                         return 0;
     
186.         }
     
187. };
     

复制代码

zjia2

多谢回答，但是状态机和和程序的异步执行有关系吗？

gnap

参看IEEE 802.1x协议的的文档。然后对照xsupplicant中的相关的代码。