答案：未定义行为 (Undefined Behavior) — 输出一个随机垃圾值。

a 声明了但未初始化，它的值是栈上随机残留的数据。我的经验是：用 -Wall -Wextra 编译，GCC 会警告 'a' is used uninitialized。永远在声明时初始化你的变量：int a = 0;。

答案：<limits.h>

INT_MAX、INT_MIN、UINT_MAX 等常量定义在 <limits.h> 中。<stdint.h> 提供 int32_t、int64_t 等精确宽度类型，但极限常量在 <limits.h>。这是我在 datatype 章节反复强调的——写数值代码前查极限常量。

答案：编译器会警告（-Wall 下），但仍然编译通过。运行时输出垃圾值。

a + b; 这一行计算了结果但没有 return！控制到达非 void 函数末尾时，返回值由寄存器中的随机值决定。修复很简单：

int add(int a, int b) {
    return a + b;  /* ✅ 加上 return */
}

我发现很多初学者会犯这个错误——写了表达式但忘了返回。编译时开 -Wreturn-type 可以捕获这类问题。

答案：编译错误 — else if 没有匹配的 if。

问题在于 if (score >= 90) 后面没有花括号，所以 printf("优秀\n"); 不属于 if，而 else if 就近匹配到了谁？实际上，C 的规则是 else 匹配最近的 if——但 printf("优秀\n"); 是一个独立语句，隔开了 if 和 else if，导致编译器报错：'else' without a previous 'if'。

修复——永远加上花括号：

if (score >= 90) {
    printf("A\n");
    printf("优秀\n");
} else if (score >= 60) {
    printf("C\n");
}

这是我第一篇「控制流」章节的「开篇故事」——我当初因为这个 bug 考了 55 分却打印了"恭喜！"。

答案：死循环。输出 0 1 2 3 3 3 3 ... 永远不停止。

当 i == 3 时，continue 跳过了 i++，所以 i 永远停留在 3，条件 i < 5 永远为真。这正是我在「循环」章节「常见错误 3」中警告的：continue 在 while 循环中会跳过递增部分。

修复——确保 continue 之前递增：

if (i == 3) {
    i++;       /* ✅ continue 前先递增 */
    continue;
}

答案：输出 11，不是 25！

宏展开是纯文本替换。SQUARE(3 + 2) 展开为：

3 + 2 * 3 + 2

按运算符优先级：3 + 6 + 2 = 11。

这是我在「预处理器」章节被坑过无数次的经典陷阱。修复——给参数和整体都加上括号：

#define SQUARE(x) ((x) * (x))  /* ✅ 现在 SQUARE(3+2) = ((3+2)*(3+2)) = 25 */

答案：是的，x = 20。

p 存储了 x 的地址，*p = 20 等价于 x = 20。这是指针最基本的用法——通过地址间接修改变量。记住：*p 就是 x 的别名。

答案：输出 30。

p 指向 arr[0]（值 10）。p + 2 前进 2 个 int 元素（每个 4 字节，共 8 字节），指向 arr[2]（值 30）。

这就是我在「指针运算」章节讲的核心规则：指针 +N 前进 N 个「元素」，不是 N 个字节。编译器自动根据指针类型（int*）计算偏移量：2 × sizeof(int) = 8 字节。

同时 *(p + 2) 完全等价于 p[2] 等价于 arr[2]——它们在编译器层面是同一件事。

答案：实际输出 1（或 2 取决于平台），不是 5。

这是 C 语言最经典的 sizeof 陷阱。当数组作为函数参数传递时，它退化为指针。所以在 print_len 中：

• sizeof(arr) = sizeof(int*) = 8 字节（64 位平台）
• sizeof(arr[0]) = sizeof(int) = 4 字节
• 8 / 4 = 2（不是 5！）

修复——在调用处计算好长度再传入：

void print_len(int *arr, size_t len) {
    printf("len = %zu\n", len);
}

int main(void) {
    int data[] = {1, 2, 3, 4, 5};
    size_t len = sizeof(data) / sizeof(data[0]);  /* ✅ 在数组定义处计算 */
    print_len(data, len);
}

我发现 90% 的初学者在这道题上栽过跟头。核心教训：一旦数组变成指针，sizeof 就再也无法知道原始长度。

答案：缓冲区溢出！"Hello" 需要 6 字节（5 个字符 + 1 个 \0），但 name 只有 5 字节。

\0 被写入了 name 数组之外的内存——这是未定义行为，可能导致崩溃或安全漏洞。

修复——使用 strncpy 并确保 null 终止：

char name[6];  /* ✅ 至少 6 字节 */
strncpy(name, "Hello", sizeof(name) - 1);
name[sizeof(name) - 1] = '\0';  /* ✅ 手动确保 null termination */

我常说：strcpy 应该在所有严肃项目中被禁用。永远使用 strncpy + 手动 \0，或者更好的 snprintf。

答案：输出 "不相等"。

a 和 b 是两个独立的数组，它们在内存中有不同的地址。a == b 比较的是指针地址（数组名退化为指向首元素的指针），不是字符串内容！两个不同的数组地址当然不相等。

正确比较字符串内容的方式：

if (strcmp(a, b) == 0) {  /* ✅ 比较内容 */
    printf("内容相等\n");
}

这是 C 字符串的"第 1 号禁忌"——永远不要用 == 比较字符串。我在「字符串深度」章节反复强调过这一点。

答案：编译错误。C 语言不支持用 == 比较结构体。

虽然 p1 和 p2 的成员值完全相同，但 C 标准没有定义结构体的 == 运算符。修复——逐成员比较：

if (p1.x == p2.x && p1.y == p2.y) {  /* ✅ 逐成员比较 */
    printf("相等\n");
}

注意：不推荐使用 memcmp(&p1, &p2, sizeof(struct Point))——结构体中可能存在 padding 字节，它们的值是不确定的，可能导致 memcmp 误报不相等。

答案：什么都不会输出——BLUE 没有被任何 case 匹配，且没有 default 分支，所以函数静默地什么都不做。

这是最危险的 bug 类型——静默失败。防止方法：永远在枚举的 switch 中加 default：

void print_color(Color c) {
    switch (c) {
        case RED:   printf("红色\n"); break;
        case GREEN: printf("绿色\n"); break;
        case BLUE:  printf("蓝色\n"); break;
        default:    printf("未知颜色(%d)\n", c); break;  /* ✅ 安全兜底 */
    }
}

我在「枚举」章节强调过：C 的枚举底层是 int，可以赋任何整数值。没有 default 就无法捕获非法值。

答案：未定义行为 (Undefined Behavior) — 可能输出 42，也可能输出随机垃圾值，也可能崩溃。

x 是 get_number 的局部变量，存储在栈上。当 get_number 返回时，x 的栈帧被销毁，但 p 仍然指向那片已经释放的内存——这就是悬垂指针 (Dangling Pointer)。

修复方案有三种：

/* 方案 1: static 变量 — 存储在 .data 段 */
int *get_number(void) {
    static int x = 42;
    return &x;
}

/* 方案 2: 堆分配 — 调用者负责 free */
int *get_number(void) {
    int *x = malloc(sizeof(int));
    *x = 42;
    return x;
}

/* 方案 3: 调用者分配 */
void get_number(int *result) {
    *result = 42;
}

这是我在「作用域」章节开篇的故事——我调了一整个下午才找到这个 bug。记住：绝不要返回局部变量的地址。

答案：未定义行为 — 可能输出 10（运气好），可能输出垃圾值，可能崩溃。

free(p) 后，p 成为悬垂指针。那块内存已经被归还给操作系统（或堆管理器），你不再拥有它。继续使用它就是 Use-After-Free——这是最危险的内存错误之一。

修复——释放后立即置 NULL：

free(p);
p = NULL;
/* printf("%d\n", p[0]); → 现在会立刻崩溃（段错误），这比静默损坏好调试得多 */

我的安全规则：free + 置 NULL 永远一起做，就像系安全带一样不能忘。

答案：内存泄漏。

当 realloc 失败时返回 NULL，但原内存不会被释放。如果直接 buf = realloc(buf, 200)，失败后 buf 变成 NULL，原内存块的地址丢失——无法再 free(buf)，造成泄漏。

修复——用临时变量保存返回值：

void *expand(void *buf) {
    void *tmp = realloc(buf, 200);
    if (tmp == NULL) {
        free(buf);   /* ✅ 失败时释放原内存 */
        return NULL;
    }
    return tmp;  /* ✅ 成功时返回新地址 */
}

这是我在「内存管理」章节「常见错误 5」中的核心教训。我发现很多人不知道 realloc 的这个行为。

答案：输出 21。&triple 可以简写为 triple——函数名会自动 decay 为函数指针，两者完全等价。

函数指针的声明语法很容易让人困惑。记住顺时针螺旋规则：从 fptr 开始，*fptr 是指针，(*fptr)(int) 是接受 int 的函数，返回 int。用 typedef 更清晰：

typedef int (*int_transform_t)(int);
int_transform_t fptr = triple;  /* 一目了然 */

答案：整数溢出导致错误的比较结果。

当 a = 5 且 b = -2147483647（约等于 INT_MIN）时，5 - (-2147483647) 会溢出 int 的范围，导致符号翻转——原本 5 > -2147483647，但溢出后的结果可能是负数，qsort 会做出错误的排序决策。

修复——用安全的三态比较：

int cmp(const void *a, const void *b) {
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);  /* ✅ 不会溢出 */
}

这是我在「回调函数」章节「常见错误 2」中强调的——永远不要假设 a - b 是安全的比较方式。INT_MIN 的存在会让减法溢出。

答案：文件可能为空或内容不完整。

fprintf 不会立即写入磁盘——数据先写到 FILE* 的内部缓冲区。如果忘记 fclose(fp)，缓冲区中的数据可能不会被刷新到磁盘，导致文件是空的或不完整的。

修复：

FILE *fp = fopen("test.txt", "w");
if (fp == NULL) { /* 错误处理 */ }
fprintf(fp, "Hello, world!\n");
fclose(fp);  /* ✅ 必须调用！刷新缓冲区 + 释放资源 */

我在「文件 I/O」章节的第一篇故事就是这个 bug——第一次写 C 文件时忘记 fclose，盯着空文件困惑了很久。

答案：

• 第一处：0x78（小端序中最低字节在地址 0）
• 第二处：0x12（0x12345678 >> 24 = 0x00000012，& 0xFF = 0x12）

解释：

• val = 0x12345678 在小端序内存中存储为：[78] [56] [34] [12]
• bytes[0] 就是最低字节 0x78
• 位运算取最高字节：右移 24 位后，0x12 移到了最低位

这道题结合了我在「void* 泛型」和「位运算」两章的核心知识。void* 让你能指向任何类型，而位运算让你能精确操控每一个 bit。这两个工具合在一起，就是 C 语言"直接操作硬件"的能力。