C语言用Switch-case语句实现状态机

#include <stdio.h>
#include <string.h>

#define SUBSTRING_LENGTH 8 // 定义子字符串的长度为8
#define MAX_MATCHES 100    // 定义最大匹配的子字符串个数

// 定义状态枚举，用于状态机的各个状态
typedef enum {
    STATE_INITIAL,    // 初始状态，还未检测到目标字符
    STATE_A,          // 已经检测到字符 'A'
    STATE_B,          // 已经检测到字符 'B'
    STATE_C,          // 已经检测到字符 'C'
    STATE_D,          // 已经检测到字符 'D'
    STATE_ANY_CHAR,   // 已经匹配 'ABCD'，正在检测任意字符
    STATE_FOUND       // 已找到符合条件的8位子字符串
} State;

// 状态机函数，查找输入字符串中是否存在符合 "ABCDxxxx" 格式的子字符串
int state_machine(const char *input, const char *matches[], int max_matches) {
    State current_state = STATE_INITIAL; // 当前状态初始化为 STATE_INITIAL
    const char *substring_start = NULL;  // 指向可能符合条件的子字符串的起始位置
    int any_char_count = 0;              // 记录匹配任意字符的个数
    int match_count = 0;                 // 记录找到的符合条件的子字符串个数

	int a = 0;
	int b = 1;
    // 循环遍历输入字符串的每一个字符
    while (*input != '\0') {
        switch (current_state) {
			case STATE_INITIAL:
                // 检测到 'A' 时，进入 STATE_A 状态，并记录子字符串的开始位置
                if (*input == 'A') {
                    current_state = STATE_A;
                    substring_start = input; // 记录子字符串的起始位置
//                    printf("%d\n", a);
//        			printf("初始指针（地址）的值为：OX%p\n", substring_start);
//        			printf("%d\n", b);
                }
                break;
			
            case STATE_A:
                // 如果当前状态是 STATE_A，检测下一个字符是否为 'B'
                if (*input == 'B') {
                    current_state = STATE_B;
//                    printf("此时指针（地址）的值为：OX%p\n", substring_start);
                } else {
                    // 如果不是 'B'，回到初始状态
                    current_state = STATE_INITIAL;
                }
                break;

            case STATE_B:
                // 如果当前状态是 STATE_B，检测下一个字符是否为 'C'
                if (*input == 'C') {
                    current_state = STATE_C;
                } else {
                    // 如果不是 'C'，回到初始状态
                    current_state = STATE_INITIAL;
                }
                break;

            case STATE_C:
                // 如果当前状态是 STATE_C，检测下一个字符是否为 'D'
                if (*input == 'D') {
                    current_state = STATE_D;
                } else {
                    // 如果不是 'D'，回到初始状态
                    current_state = STATE_INITIAL;
                }
                break;

            case STATE_D:
                // 已经匹配到 "ABCD"，接下来开始匹配任意的四个字符
                current_state = STATE_ANY_CHAR;
                any_char_count = 1; // 记录已经匹配了一个任意字符
                break;

            case STATE_ANY_CHAR:
                // 任意字符的数量增加
                any_char_count++;
                // 如果匹配到了四个任意字符，进入 STATE_FOUND 状态
                if (any_char_count == 4) {
                    current_state = STATE_FOUND;
                    continue;
                }else{
                	break;
				}

            case STATE_FOUND:
                // 如果找到符合条件的8位子字符串，将其地址存储到 matches 数组中
                if (match_count < max_matches) {
                    matches[match_count++] = substring_start;
                }
                // 继续搜索下一个子字符串，重置状态机
                current_state = STATE_INITIAL;
                input = substring_start + 1; // 移动到下一个字符继续检测
                continue;
        }
        input++; // 移动到下一个字符
    }

    return match_count; // 返回找到的符合条件的子字符串个数
}

int main() {
    const char *test_string = "XYABCDxxxxYZZABCD1234ABCDEFABCD5678"; // 测试字符串
    const char *matches[MAX_MATCHES]; // 保存所有匹配的子字符串
    int match_count = state_machine(test_string, matches, MAX_MATCHES); // 调用状态机函数

    // 输出找到的所有符合条件的子字符串
    printf("初始字符串是:%s\n", test_string);
    if (match_count > 0) {
        int i; // 在循环外部提前声明变量 i
        printf("找到 %d 个符合条件的子字符串:\n", match_count);
        for (i = 0; i < match_count; i++) {
            printf("子字符串 %d: %.8s\n", i + 1, matches[i]);
        }
    } else {
        printf("没有找到符合条件的子字符串。\n");
    }

    return 0;
}