【嵌入式面试】嵌入式笔试与面试宝典（offer必来）

兰舟比特

于 2025-07-25 18:06:36 发布

阅读量778

点赞数 27

CC 4.0 BY-SA版权

分类专栏：嵌入式面试文章标签：面试 c语言系统架构数据结构单片机 stm32 物联网

本文链接：https://blog.youkuaiyun.com/CUI9015/article/details/149645439

嵌入式面试专栏收录该内容

4 篇文章

订阅专栏

💌 所属专栏：【嵌入式面试】
😀 作者：兰舟比特 🐾
🚀 个人简介：热爱开源系统与嵌入式技术，专注 Linux、网络通信、编程技巧、面试总结与软件工具分享，持续输出实用干货！
💡 欢迎大家：这里是兰舟比特的技术小站，喜欢的话请点赞、收藏、评论三连击！有问题欢迎留言交流😘😘😘

📚 嵌入式开发笔试与面试终极宝典：从入门到精通

摘要：本文是一份全面、系统的嵌入式开发面试指南，涵盖了C语言、操作系统、硬件知识、通信协议、项目经验等核心领域。无论你是准备面试的求职者，还是需要评估候选人的面试官，这份宝典都将为你提供宝贵参考。文中包含200+高频面试题、详细解析和实用技巧，助你轻松应对嵌入式岗位的挑战！

前言：嵌入式面试的现状与趋势

嵌入式系统开发是连接软件与硬件的桥梁，随着物联网、智能硬件、工业4.0的兴起，嵌入式人才需求持续增长。然而，嵌入式岗位的面试门槛也相对较高，不仅要求扎实的编程基础，还需要对硬件、操作系统、通信协议等有深入理解。

根据2023年行业调研数据：

85%的嵌入式岗位要求精通C语言
70%的岗位要求熟悉至少一种RTOS（如FreeRTOS、uC/OS）
65%的岗位要求具备硬件调试能力
50%的岗位要求掌握常见通信协议（I2C、SPI、UART等）

本文将带你系统梳理嵌入式面试的核心知识点，帮助你从容应对各种挑战！

第一部分：C语言核心知识

C语言是嵌入式开发的基石，面试官通常会通过C语言问题考察候选人的底层编程能力。

🔹 基础概念

1. `#define` 和 `const` 的区别是什么？

答案：

#define 是预处理指令，在编译前进行文本替换，没有类型检查，不占用内存
const 是常量修饰符，具有类型信息，编译时分配内存，遵循作用域规则
举例：#define PI 3.14 vs const float PI = 3.14f;
应用场景：宏适合用于条件编译和简单替换；const适合用于需要类型安全的常量

2. `volatile` 关键字的作用是什么？请举例说明

答案：

volatile 告诉编译器该变量可能会被意外修改（如中断、DMA、多线程），禁止编译器优化
应用场景：
- 寄存器访问：volatile uint32_t *reg = (volatile uint32_t *)0x40000000;
- 中断服务程序中的变量：volatile int flag = 0;
- 多线程共享变量
错误示例：没有volatile修饰的中断标志位可能导致编译器优化掉检查语句

3. `static` 关键字在不同上下文中的作用

答案：

函数内部：静态局部变量，生命周期延长至程序运行结束，但作用域仍限于函数内
文件作用域：限制变量或函数的作用域为本文件（隐藏），防止与其他文件中的同名标识符冲突
C++类中：属于类而非对象的成员变量或函数

4. `extern "C"` 的作用是什么？

答案：

在C++代码中使用，告诉编译器以C语言的方式链接函数
解决C++的名称修饰（name mangling）问题，确保C和C++代码可以互相调用

典型用法：

#ifdef __cplusplus
extern "C" {
#endif

void my_function(void);

#ifdef __cplusplus
}
#endif

🔹 指针与内存管理

5. 解释以下声明的含义：

int *p[10];
int (*p)[10];
int *p(void);
int (*p)(void);

答案：

int *p[10]; —— 指针数组，包含10个指向int的指针
int (*p)[10]; —— 指向包含10个int的数组的指针
int *p(void); —— 返回指向int的指针的函数
int (*p)(void); —— 指向无参数、返回int的函数的指针

6. 堆和栈的区别有哪些？

答案：

特性	栈	堆
分配方式	自动分配（函数调用时）	手动分配（malloc/calloc/realloc）
生命周期	函数调用结束自动释放	显式释放（free）后才释放
分配效率	高（CPU寄存器直接管理）	相对低（需要系统调用）
碎片问题	不易产生碎片	容易产生碎片
大小限制	通常较小（几MB）	通常较大（受系统内存限制）
访问速度	快	相对慢

7. `memcpy` 和 `memmove` 的区别是什么？为什么需要`memmove`？

答案：

memcpy：简单内存拷贝，当源地址和目标地址有重叠时，行为未定义
memmove：处理内存重叠情况，先将数据复制到临时缓冲区，再复制到目标位置
示例：memmove(buf, buf+1, 9) 安全，而 memcpy(buf, buf+1, 9) 可能导致数据损坏

🔹 位操作与硬件相关

8. 如何用C语言设置/清除寄存器的某一位？

答案：

// 设置第n位（置1）
#define SET_BIT(REG, N) ((REG) |= (1U << (N)))

// 清除第n位（置0）
#define CLR_BIT(REG, N) ((REG) &= ~(1U << (N)))

// 翻转第n位
#define TOGGLE_BIT(REG, N) ((REG) ^= (1U << (N)))

// 检查第n位
#define CHECK_BIT(REG, N) (((REG) >> (N)) & 0x1)

9. 如何判断系统是大端还是小端？

答案：

int is_little_endian() {
    int num = 1;
    return *((char *)&num) == 1;
}

小端系统：低位字节在低地址（如x86、ARM默认）
大端系统：高位字节在低地址（如网络字节序、某些PowerPC）

10. 用位运算判断一个整数是否是2的幂次方

答案：

int is_power_of_two(unsigned int n) {
    return n > 0 && (n & (n - 1)) == 0;
}

原理：2的幂次方的二进制表示只有一位是1，减1后该位变为0，其余低位全为1

🔹 结构体与联合体

11. 结构体内存对齐的原则是什么？

答案：

结构体变量的首地址必须是结构体中最大成员大小的整数倍
每个成员相对于结构体首地址的偏移量必须是该成员大小的整数倍
结构体总大小必须是结构体中最大成员大小的整数倍

示例：

struct Example {
    char a;    // 1字节
    int b;     // 4字节，需要4字节对齐，前面填充3字节
    short c;   // 2字节
};             // 总大小为12字节（8+4对齐）

12. 什么是柔性数组？有什么作用？

答案：

柔性数组（Flexible Array Member）是C99引入的特性，指结构体最后一个成员定义为type name[]
作用：实现可变长度的结构体，节省内存

示例：

typedef struct {
    int length;
    char data[];  // 柔性数组
} Buffer;

// 分配内存
Buffer *buf = malloc(sizeof(Buffer) + 100);
buf->length = 100;
strcpy(buf->data, "Hello");

优势：相比指针方式，内存连续，减少碎片

13. `#pragma pack(1)` 的作用是什么？

答案：

关闭结构体默认的内存对齐，按照1字节对齐
应用场景：网络协议、文件格式等需要精确内存布局的场合
注意：可能降低访问速度，因为CPU通常对对齐的内存访问更快

第二部分：数据结构与算法

🔹 基础数据结构

14. 实现一个单向链表，并写出插入和删除操作

答案：

typedef struct Node {
    int data;
    struct Node *next;
} Node;

// 在头部插入
void insert_front(Node **head, int data) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = data;
    new_node->next = *head;
    *head = new_node;
}

// 删除指定值的节点
void delete_node(Node **head, int key) {
    Node *current = *head;
    Node *prev = NULL;
    
    // 如果头节点就是要删除的
    if (current != NULL && current->data == key) {
        *head = current->next;
        free(current);
        return;
    }
    
    // 查找要删除的节点
    while (current != NULL && current->data != key) {
        prev = current;
        current = current->next;
    }
    
    // 如果没找到
    if (current == NULL) return;
    
    // 删除节点
    prev->next = current->next;
    free(current);
}

15. 实现一个环形缓冲区（循环队列）

答案：

typedef struct {
    uint8_t *buffer;
    int head;
    int tail;
    int size;
    bool full;
} CircularBuffer;

void cb_init(CircularBuffer *cb, uint8_t *buf, int size) {
    cb->buffer = buf;
    cb->head = 0;
    cb->tail = 0;
    cb->size = size;
    cb->full = false;
}

bool cb_is_empty(CircularBuffer *cb) {
    return (!cb->full && (cb->head == cb->tail));
}

bool cb_is_full(CircularBuffer *cb) {
    return cb->full;
}

int cb_put(CircularBuffer *cb, uint8_t data) {
    if (cb->full) {
        return -1; // 缓冲区已满
    }
    
    cb->buffer[cb->head] = data;
    cb->head = (cb->head + 1) % cb->size;
    
    if (cb->head == cb->tail) {
        cb->full = true;
    }
    
    return 0;
}

int cb_get(CircularBuffer *cb, uint8_t *data) {
    if (cb_is_empty(cb)) {
        return -1; // 缓冲区为空
    }
    
    cb->full = false;
    *data = cb->buffer[cb->tail];
    cb->tail = (cb->tail + 1) % cb->size;
    
    return 0;
}

🔹 常用算法

16. 实现一个快速排序算法

答案：

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

17. 如何计算一个字节中1的位数（汉明重量）？

答案：

// 方法1：逐位检查
int count_bits1(uint8_t byte) {
    int count = 0;
    while (byte) {
        count += byte & 0x01;
        byte >>= 1;
    }
    return count;
}

// 方法2：高效算法（Brian Kernighan算法）
int count_bits2(uint8_t byte) {
    int count = 0;
    while (byte) {
        byte &= (byte - 1); // 清除最低位的1
        count++;
    }
    return count;
}

// 方法3：查表法（最快）
const uint8_t bit_count[256] = {
    #define B2(n) n, n+1, n+1, n+2
    #define B4(n) B2(n), B2(n+1), B2(n+1), B2(n+2)
    #define B6(n) B4(n), B4(n+1), B4(n+1), B4(n+2)
    B6(0), B6(1), B6(1), B6(2)
};

int count_bits3(uint8_t byte) {
    return bit_count[byte];
}

18. 实现CRC-16校验算法

答案：

uint16_t crc16(const uint8_t *data, size_t length) {
    uint16_t crc = 0xFFFF;
    uint16_t poly = 0xA001; // CRC-16-CCITT多项式
    
    for (size_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (int j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc = (crc >> 1) ^ poly;
            } else {
                crc >>= 1;
            }
        }
    }
    
    return crc;
}

第三部分：操作系统与RTOS

🔹 基础概念

19. 进程和线程的区别是什么？

答案：

特性	进程	线程
定义	程序的执行实例	进程内的执行单元
资源	拥有独立的内存空间、文件描述符等	共享所属进程的资源
创建开销	大（需要复制地址空间）	小（只需创建栈和寄存器）
通信方式	IPC（管道、消息队列、共享内存等）	共享内存、信号量等
隔离性	高（一个进程崩溃不影响其他进程）	低（一个线程崩溃可能导致整个进程崩溃）
切换开销	大	小

20. 什么是死锁？产生的条件有哪些？

答案：

死锁：多个进程/线程因争夺资源而相互等待，导致程序无法继续执行的状态
四个必要条件（必须同时满足）：
1. 互斥：资源一次只能被一个进程使用
2. 请求与保持：进程已持有资源，又请求其他资源
3. 不可抢占：已分配的资源不能被强制收回
4. 循环等待：存在进程资源循环等待链

21. 什么是优先级反转？如何解决？

答案：

优先级反转：高优先级任务因等待低优先级任务持有的资源而被中等优先级任务阻塞的现象
解决方案：
1. 优先级继承：当高优先级任务等待低优先级任务持有的资源时，临时提升低优先级任务的优先级
2. 优先级天花板：为每个资源设置一个"天花板优先级"，获取资源的任务优先级临时提升到该值

🔹 FreeRTOS专题

22. FreeRTOS中任务的状态有哪些？

答案：

运行态（Running）：当前正在执行的任务
就绪态（Ready）：任务已准备好运行，等待调度器选择
阻塞态（Blocked）：任务等待某个事件（如信号量、队列、延时）
挂起态（Suspended）：任务被显式挂起，不参与调度

23. FreeRTOS中的队列、信号量和事件组有什么区别？

答案：

机制	特点	适用场景
队列	传递数据，FIFO，有缓冲区	任务间数据传递
信号量	二进制或计数信号量，不传递数据	资源管理、任务同步
互斥量	带优先级继承的二进制信号量	临界区保护
事件组	多个事件标志的组合	多条件同步

24. FreeRTOS中中断处理的注意事项有哪些？

答案：

中断优先级：高于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断不能调用FreeRTOS API
ISR中操作：应尽量简短，复杂逻辑交给任务处理
FromISR API：必须使用专门的FromISR版本API（如xQueueSendFromISR）
任务切换：需要调用portYIELD_FROM_ISR()请求任务切换
清除中断标志：务必在ISR中清除中断标志，防止重复触发

25. 解释FreeRTOS的任务调度机制

答案：

抢占式调度：高优先级任务就绪时立即抢占CPU
时间片轮转：同优先级任务按时间片轮流执行
就绪列表：每个优先级对应一个就绪任务列表
调度触发点：
- 任务阻塞（如vTaskDelay）
- 事件触发（如xQueueSend）
- 主动让出（taskYIELD）
- 中断处理完成

🔹 uC/OS-II专题

26. uC/OS-II的任务调度过程是怎样的？

答案：

调用OS_Sched()函数
查找最高优先级就绪任务
如果新任务优先级高于当前任务：
- 保存当前任务上下文（CPU寄存器）
- 切换到新任务栈
- 恢复新任务上下文
- 执行新任务

27. uC/OS-II中的事件控制块（ECB）是什么？

答案：

ECB：用于管理任务等待事件的数据结构
包含：
- 事件类型（信号量、邮箱、队列等）
- 事件状态
- 等待任务列表
作用：实现任务同步和通信

第四部分：硬件与单片机知识

🔹 基础硬件知识

28. 解释GPIO的工作原理和配置模式

答案：

GPIO：通用输入输出引脚，可配置为输入或输出
配置模式：
- 输入模式：
  - 浮空输入：引脚悬空，需外部上拉/下拉
  - 上拉输入：内部上拉电阻，默认高电平
  - 下拉输入：内部下拉电阻，默认低电平
  - 模拟输入：连接到ADC
- 输出模式：
  - 推挽输出：高低电平均可主动驱动
  - 开漏输出：只能拉低，需外部上拉
  - 复用推挽/开漏：用于外设功能

29. 什么是看门狗定时器（WDT）？有什么作用？

答案：

看门狗：一种硬件定时器，用于检测和恢复程序跑飞
工作原理：
1. 系统正常运行时定期"喂狗"（重置计数器）
2. 如果程序跑飞未能及时喂狗，计数器溢出触发系统复位
作用：提高系统可靠性，防止死机

30. 解释ADC的工作原理和关键参数

答案：

工作原理：将模拟信号转换为数字信号
1. 采样：在特定时间点捕获模拟信号
2. 保持：保持采样值稳定
3. 量化：将模拟值映射到离散数字值
4. 编码：生成二进制数字输出
关键参数：
- 分辨率：位数（如12-bit），决定精度
- 采样率：每秒采样次数
- 信噪比（SNR）：信号与噪声的比值
- 总谐波失真（THD）：非线性失真程度

🔹 STM32专题

31. STM32的启动流程是怎样的？

答案：

上电复位
从启动文件（如startup_stm32f4xx.s）开始执行
初始化堆栈指针（SP）
跳转到Reset_Handler
系统时钟配置
数据段（.data）初始化
BSS段（.bss）清零
调用SystemInit()
调用main()

32. STM32中NVIC的作用是什么？

答案：

NVIC（Nested Vectored Interrupt Controller）：嵌套向量中断控制器
功能：
- 管理中断优先级
- 支持中断嵌套
- 处理中断向量表
- 实现低延迟中断响应
特点：
- 可配置优先级分组
- 支持软件触发中断
- 提供系统异常处理

33. STM32的低功耗模式有哪些？如何进入和退出？

答案：

三种低功耗模式：
1. 睡眠模式（Sleep）：
  - 内核停止，外设继续工作
  - 通过中断/事件唤醒
  - 退出：任意中断
2. 停机模式（Stop）：
  - 内核和大部分外设停止
  - 1.2V区域仍工作
  - 通过外部中断/RTC唤醒
  - 退出：特定中断
3. 待机模式（Standby）：
  - 几乎所有电路关闭
  - 仅备份域和唤醒逻辑工作
  - 功耗最低
  - 退出：复位或WKUP引脚

第五部分：通信协议与接口

🔹 基础通信协议

34. 比较UART、SPI和I2C的区别

答案：

特性	UART	SPI	I2C
通信方式	异步	同步	同步
时钟	无	有（SCLK）	有（SCL）
数据线	TX、RX（2线）	MOSI、MISO（2线）	SDA（1线）
速度	中等（通常<1Mbps）	高（可达几十Mbps）	低（通常<400Kbps）
拓扑结构	点对点	主从结构	多主多从
寻址	无	通过CS片选	7/10位地址
优点	简单，无需时钟	速度快，全双工	线少，支持多设备
缺点	无错误检测	线多，距离短	速度慢，复杂

35. CAN总线的特点和应用场景

答案：

特点：
- 多主结构，无中心节点
- 差分信号传输，抗干扰能力强
- 帧格式包含ID，支持优先级
- 具有错误检测和自动重传机制
- 传输速率可达1Mbps（40m内）
应用场景：
- 汽车电子控制系统（ECU通信）
- 工业自动化
- 医疗设备
- 航空航天

🔹 网络协议

36. TCP和UDP的区别是什么？

答案：

特性	TCP	UDP
连接	面向连接（三次握手）	无连接
可靠性	可靠（确认、重传、排序）	不可靠（尽力而为）
流量控制	有（滑动窗口）	无
拥塞控制	有	无
速度	较慢（开销大）	快（开销小）
数据边界	无（字节流）	有（数据报）
应用场景	文件传输、Web浏览	视频流、实时游戏、DNS

37. 什么是LwIP？它在嵌入式系统中的作用是什么？

答案：

LwIP（Lightweight IP）：轻量级TCP/IP协议栈
特点：
- 内存占用小（RAM约几十KB，ROM几百KB）
- 支持核心TCP/IP协议
- 可配置，适应不同资源限制
- 支持RAW API、NETCONN API和Socket API
作用：
- 为资源受限的嵌入式设备提供网络功能
- 实现设备联网、远程控制、数据传输等

第六部分：项目经验与场景题

🔹 项目经验

38. 请描述一个你参与过的嵌入式项目

回答建议：

STAR法则：Situation（背景）、Task（任务）、Action（行动）、Result（结果）
结构示例：
1. 项目背景与目标（1-2句话）
2. 技术栈：使用的MCU、RTOS、外设等
3. 你的职责与贡献（重点！）
4. 遇到的挑战及解决方案
5. 项目成果与收获

示例：

“我参与开发了一款基于STM32F4的智能环境监测仪（Situation）。我的任务是负责传感器数据采集和低功耗管理模块（Task）。我使用FreeRTOS创建了多个任务处理不同传感器数据，并实现了基于RTC的定时唤醒机制以降低功耗（Action）。最终产品在待机模式下功耗降低了60%，连续工作时间达到7天，项目成功量产（Result）。”

39. 你在项目中遇到的最大挑战是什么？如何解决的？

回答建议：

选择真实、有技术含量的挑战
重点描述你的思考过程和解决方案
体现你的问题解决能力和学习能力
避免抱怨团队或推卸责任

示例：

“在开发一款低功耗蓝牙设备时，我们遇到了蓝牙模块与主MCU通信不稳定的问题（Challenge）。我首先通过逻辑分析仪捕获通信数据，发现是SPI时钟相位配置不匹配导致的（Analysis）。然后我查阅了两个芯片的数据手册，调整了SPI时钟极性和相位设置，并添加了适当的延时（Solution）。最后，我编写了自动化测试脚本验证稳定性，问题得到彻底解决（Verification）。”

🔹 场景题

40. 如果串口通信收不到数据，你会如何排查？

答案：

检查物理连接：
- TX-RX是否交叉连接
- 电平是否匹配（TTL vs RS232）
- 线缆是否损坏
检查配置参数：
- 波特率、数据位、停止位、校验位是否一致
- 流控制设置
检查软件实现：
- 是否正确初始化串口
- 是否开启接收中断或DMA
- 接收缓冲区是否溢出
使用工具辅助：
- 逻辑分析仪/示波器查看信号
- 串口助手测试收发
- 添加调试输出（如LED指示）
逐步排查：
- 先测试自发自收
- 再测试与已知正常设备通信
- 最后检查协议层问题

41. 如何优化嵌入式系统的功耗？

答案：

硬件层面：
- 选择低功耗MCU和外设
- 优化电路设计（如使用LDO代替DC-DC）
- 关闭未使用的外设电源
软件层面：
- 合理使用低功耗模式（Sleep/Stop/Standby）
- 降低系统时钟频率
- 减少外设工作时间
- 优化任务调度，减少CPU活跃时间
系统设计：
- 采用事件驱动代替轮询
- 延长采样间隔
- 休眠前保存状态，唤醒后快速恢复
测量与优化：
- 使用电流表监测各模块功耗
- 识别功耗热点
- 迭代优化

第七部分：笔试常见题型与解法

🔹 选择题

42. 在C语言中，以下代码的输出是什么？

#include <stdio.h>
int main() {
    int a = 5;
    printf("%d %d %d", a, a++, ++a);
    return 0;
}

答案：

未定义行为！函数参数的求值顺序是未定义的
不同编译器可能输出不同结果
关键点：避免在单个表达式中多次修改同一变量

43. 下列哪个是合法的C语言标识符？

A. 3var B. _var C. my-var D. int

答案：

B. _var
规则：标识符必须以字母或下划线开头，后续字符可以是字母、数字或下划线

🔹 填空题

44. 在32位系统中，以下结构体的大小是____字节：

struct {
    char a;
    int b;
    short c;
} s;

答案：

12字节
解析：
- char a：1字节（偏移0）
- 填充3字节（偏移1-3，保证int对齐）
- int b：4字节（偏移4-7）
- short c：2字节（偏移8-9）
- 填充2字节（偏移10-11，保证总大小为4的倍数）

🔹 编程题

45. 编写一个函数，反转一个单向链表

答案：

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node* reverse_list(Node *head) {
    Node *prev = NULL;
    Node *current = head;
    Node *next = NULL;
    
    while (current != NULL) {
        next = current->next;  // 保存下一个节点
        current->next = prev;  // 反转指针
        prev = current;        // 移动prev
        current = next;        // 移动current
    }
    
    return prev;  // 新的头节点
}

46. 实现一个状态机，识别字符串"embedded"

答案：

typedef enum {
    STATE_START,
    STATE_E,
    STATE_EM,
    STATE_EMB,
    STATE_EMBE,
    STATE_EMBED,
    STATE_EMBEDE,
    STATE_EMBEDDE,
    STATE_EMBEDDED,
    STATE_FAIL
} State;

int is_embedded(const char *str) {
    State state = STATE_START;
    
    for (int i = 0; str[i] != '\0'; i++) {
        char c = str[i];
        
        switch (state) {
            case STATE_START:
                state = (c == 'e') ? STATE_E : STATE_FAIL;
                break;
            case STATE_E:
                state = (c == 'm') ? STATE_EM : STATE_FAIL;
                break;
            case STATE_EM:
                state = (c == 'b') ? STATE_EMB : STATE_FAIL;
                break;
            case STATE_EMB:
                state = (c == 'e') ? STATE_EMBE : STATE_FAIL;
                break;
            case STATE_EMBE:
                state = (c == 'd') ? STATE_EMBED : STATE_FAIL;
                break;
            case STATE_EMBED:
                state = (c == 'd') ? STATE_EMBEDE : STATE_FAIL;
                break;
            case STATE_EMBEDE:
                state = (c == 'e') ? STATE_EMBEDDE : STATE_FAIL;
                break;
            case STATE_EMBEDDE:
                state = (c == 'd') ? STATE_EMBEDDED : STATE_FAIL;
                break;
            default:
                return 0;  // STATE_FAIL
        }
        
        if (state == STATE_EMBEDDED) {
            return 1;  // 找到匹配
        }
    }
    
    return 0;  // 未找到
}