（十三）嵌入式面试题收集:6道

问题 1：分别画出由 RC 和 LC 组成的低通滤波电路和高通滤波电路（修正 "R0" 为 "RC"）

1. RC 低通滤波电路

• 电路结构：电阻 R 与电容 C 串联，输入信号接 R 的一端，输出信号从电容 C 两端引出（地与 C 非 R 连接端）。

• 核心注释 ：

  plaintext

  输入 → R → C → 地
          ↑
         输出（C两端）
  // 原理：电容容抗Xc=1/(2πfC)，频率f越低，Xc越大，低频信号绝大部分落在C两端被输出；
  // 高频信号Xc极小，近似短路，高频信号被接地，无法输出，实现低通。

2. RC 高通滤波电路

• 电路结构：电阻 R 与电容 C 串联，输入信号接 C 的一端，输出信号从电阻 R 两端引出（地与 R 非 C 连接端）。

• 核心注释 ：

  plaintext

  输入 → C → R → 地
          ↑
         输出（R两端）
  // 原理：高频信号Xc极小，可顺利通过电容，在R两端形成输出；
  // 低频信号Xc极大，难以通过电容，R两端无有效信号，实现高通。

3. LC 低通滤波电路

• 电路结构：电感 L 与电容 C 并联，输入接并联电路一端，输出接并联电路另一端（地接并联电路公共端）。

• 核心注释 ：

  plaintext

        ┌─ L ─┐
  输入 ─┤      ├─ 输出
        └─ C ─┘
          ↓
         地
  // 原理：电感感抗Xl=2πfL，低频信号Xl小，近似短路，可通过L传输；
  // 高频信号Xc小，近似短路，高频信号被C接地，无法输出，实现低通。

4. LC 高通滤波电路

• 电路结构：电感 L 与电容 C 串联，输入接 C 的一端，输出接 L 的非 C 连接端（地接 L 另一端）。

• 核心注释 ：

  plaintext

  输入 → C → L → 地
          ↑
         输出（L非C端）
  // 原理：高频信号Xc小，可通过C，且L对高频阻碍小，形成有效输出；
  // 低频信号Xl小，近似短路，低频信号被L接地，且C对低频阻碍大，无法输出，实现高通。

问题 2：计算结构体 s2 的内存大小（64 位操作系统）

前置规则（注释）

/* 64位系统内存对齐规则：
1. 基本类型自身对齐：char(1)、bool(1)、short(2)、int(4)、double(8)、long double(16)、指针(8)；
2. 结构体整体对齐：最终大小为结构体中最大基本类型对齐值的整数倍；
3. 成员对齐：每个成员起始地址为自身对齐值的整数倍，不足则补空字节（填充）。
*/

步骤 1：计算 struct s1 的大小（带逐行注释）

struct s1{
    char a;        // 1字节，自身对齐1 → 起始地址0，占用[0]，补15字节填充（凑8？不，最大基本类型是long double(16)，对齐单位16）→ 实际占用[0-15]（16字节）
    bool b;        // 1字节，自身对齐1 → 起始地址16，占用[16]，累计17字节
    (char*) c[2];  // 2个字符指针，每个8字节，共16字节 → 起始地址17（非8倍数），补15字节填充到32，占用[32-47]，累计48字节
    int d;         // 4字节，自身对齐4 → 起始地址48（4的倍数），占用[48-51]，累计52字节
    const char* f; // 8字节，自身对齐8 → 起始地址52（非8倍数），补4字节填充到56，占用[56-63]，累计64字节
    long double(*g)[2]; // 函数指针（本质指针），8字节 → 起始地址64（8的倍数），占用[64-71]，累计72字节（非16倍数，补8字节到80）
    double e[2];   // 2个double，每个8字节，共16字节 → 起始地址80（8的倍数），占用[80-95]，累计96字节
};
// struct s1最大基本类型对齐值：long double(16)，96是16的整数倍 → s1大小=96字节

步骤 2：计算 struct s2 的大小（带逐行注释）

struct s2{
    int *a1[2];    // 2个int指针，每个8字节，共16字节 → 起始地址0，占用[0-15]，累计16字节
    char b1[3];    // 3字节char数组，自身对齐1 → 起始地址16，占用[16-18]，累计19字节（补1字节填充到20，凑short对齐值2）
    short c1;      // 2字节short，自身对齐2 → 起始地址20（2的倍数），占用[20-21]，累计22字节（补2字节填充到24，凑8的倍数）
    struct s1 s3;  // 嵌套结构体s1，大小96字节，对齐值16 → 起始地址24（非16倍数，补0？24是8倍数，s1对齐值16，补8字节到32）→ 占用[32-127]，累计128字节
    int (*e1)[4];  // 数组指针（本质指针），8字节 → 起始地址128（8的倍数），占用[128-135]，累计136字节？
    // 修正：重新逐行精准计算
    int *a1[2];    // [0-15] → 16字节（2×8）
    char b1[3];    // [16-18] → 3字节，累计19 → 补1字节（[19]）→ 20字节（凑short对齐）
    short c1;      // [20-21] → 2字节，累计22 → 补2字节（[22-23]）→ 24字节（凑8倍数）
    struct s1 s3;  // [24-119] → 96字节，累计24+96=120字节
    int (*e1)[4];  // [120-127] → 8字节，累计128字节
};
// struct s2最大基本类型对齐值：指针(8)，128是8的整数倍 → s2大小=128字节
/* 最终结论：
struct s1 内存大小：96字节
struct s2 内存大小：128字节
*/

---

问题 1：指针运算代码的运算结果

代码：

#include <stdio.h>
int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *p = arr + 5;
    int *q = arr + 3;
    printf("%d\n", p - q);
    printf("%d\n", (char*)p - (char*)q);
    return 0;
}

答案及注释：

1. p - q的结果：2

   • 指针相减（同类型），结果是 "元素个数差"。p指向arr[5]，q指向arr[3]，差值为5-3=2。

2. (char*)p - (char*)q的结果：8

   • 强转为char*后，指针相减的结果是 "字节数差"。64 位系统中int占 4 字节，2个int元素对应的字节数是2×4=8。

问题 2：无符号数与有符号数运算的代码结果

代码：

#include <stdio.h>
int main() {
    unsigned int a = 1;
    int b = -2;
    if (a + b > 0) {
        printf("Positive\n");
    } else {
        printf("Non-positive\n");
    }
    return 0;
}

答案及注释 ：输出：Positive

• 当unsigned int与int运算时，int会被隐式转换为unsigned int。
• b=-2转unsigned int后是 "无符号最大值 - 1"（64 位系统中为4294967294），与a=1相加得4294967295，远大于 0，因此进入if分支。

问题 3：宏定义SQUARE(x)的潜在问题（代码未完整展示，补充常见考点）

代码片段：

#include <stdio.h>
#define SQUARE(x) x * x

常见考点示例 ：若执行SQUARE(2+3)，结果是11（而非25）

• 宏是 "文本替换"，SQUARE(2+3)会被替换为2+3*2+3，按运算优先级计算得2+6+3=11。
• 正确写法应加括号：#define SQUARE(x) (x) * (x)（或((x)*(x))）。

---