对 C 语言系统教程的第二章和第三章添加了参考答案 (#108)

* 对C_tutorials 第六章的状态机示例代码添加了注释

* 对C_tutorials 第六章的状态机示例代码添加了注释（修正版）

* docs(vol1): refine state machine comments

追加到 PR #104 的 review 修正,纯注释、零逻辑改动:

- payload_len / index: 把「几个负载」改成「几个字节」, 代码实际含义如此，负载更像是完整的Payload，跟代码还是具备实际差距
- kStateHeader: 修正为「帧头已收完,接下来等长度字节」,
- 顺手修了结构体注释的对齐(payload[64])

* 对C_tutorials 第二章的练习题添加了参考答案

Added example solutions for exercises on data types and overflow in C.

* 对C_tutorials 第三章的练习题添加了参考答案

* fix: lint issue

---------

Co-authored-by: Charliechen114514 <725610365@qq.com>

Author: owollz4

documents/vol1-fundamentals/c_tutorials/02A-data-types-basics.md

@@ -284,6 +284,52 @@ uint8_t z{1000};    // C++ 编译错误！1000 超出 uint8_t 范围
 
 提示：可以用一个宏来减少重复代码。
 
+### 练习 1 参考答案
+
+```c
+#include <stdio.h>
+#include <stdint.h>
+//#include <stddef.h>
+
+int main() {
+    // 基本类型
+    printf("sizeof(char)      = %zu bytes\n", sizeof(char));
+    printf("sizeof(short)     = %zu bytes\n", sizeof(short));
+    printf("sizeof(int)       = %zu bytes\n", sizeof(int));
+    printf("sizeof(long)      = %zu bytes\n", sizeof(long));
+    printf("sizeof(long long) = %zu bytes\n", sizeof(long long));
+
+    // 定长整数类型 (需包含 <stdint.h>)
+    printf("sizeof(int8_t)    = %zu bytes\n", sizeof(int8_t));
+    printf("sizeof(uint8_t)   = %zu bytes\n", sizeof(uint8_t));
+    printf("sizeof(int32_t)   = %zu bytes\n", sizeof(int32_t));
+    printf("sizeof(uint32_t)  = %zu bytes\n", sizeof(uint32_t));
+    printf("sizeof(int64_t)   = %zu bytes\n", sizeof(int64_t));
+
+    // size_t 类型 (需包含<stdio.h>、 <stddef.h> 或 <stdlib.h>)
+    printf("sizeof(size_t)    = %zu bytes\n", sizeof(size_t));
+
+    return 0;
+}
+
+```
+
+```text
+sizeof(char)      = 1 bytes
+sizeof(short)     = 2 bytes
+sizeof(int)       = 4 bytes
+sizeof(long)      = 4 bytes
+sizeof(long long) = 8 bytes
+sizeof(int8_t)    = 1 bytes
+sizeof(uint8_t)   = 1 bytes
+sizeof(int32_t)   = 4 bytes
+sizeof(uint32_t)  = 4 bytes
+sizeof(int64_t)   = 8 bytes
+sizeof(size_t)    = 8 bytes
+```
+
+注意 `sizeof(long)` 这里是 4，但 `sizeof(size_t)` 已经是 8 了，说明这份输出来自 LLP64 环境（比如 64 位 Windows）：这种模型下指针 8 字节，`long` 却只有 4。换到 64 位的 Linux 或 macOS（LP64），`long` 就是 8 字节。你在自己机器上看到 `sizeof(long) = 8`，程序没写错，是数据模型的差别。
+
 ### 练习 2：溢出观察
 
 分别对有符号 `int` 和无符号 `unsigned int` 做溢出实验：
@@ -306,6 +352,29 @@ int main(void)
 
 编译运行，观察两者的行为差异。然后加上 `-fsanitize=undefined` 选项重新编译，看看有什么变化。
 
+### 练习 2 参考答案
+
+假设该文件名为overflow.c
+
+使用 gcc overflow.c -o overflow && ./overflow 编译运行后，你大概率会看到如下输出：
+
+```text
+INT_MAX  = 2147483647,  INT_MAX + 1  = -2147483648
+UINT_MAX = 4294967295, UINT_MAX + 1 = 0
+```
+
+使用 gcc -fsanitize=undefined overflow.c -o overflow_ubsan && ./overflow_ubsan 编译运行后，你会看到类似如下的输出：
+
+```text
+INT_MAX  = 2147483647,  INT_MAX + 1  = -2147483648
+overflow.c:9:54: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'
+UINT_MAX = 4294967295, UINT_MAX + 1 = 0
+```
+
+为什么？
+实际上 C 标准其实并没有对带有符号的整数的溢出进行定义，也就是说，对INT_MAX进行+1这个操作严格意义上是一个未定义行为。
+（只不过溢出很好用，也是大部分编译器都默认支持溢出的。）
+
 ## 参考资源
 
 - [cppreference: C 语言整型](https://en.cppreference.com/w/c/language/integer_constant)

documents/vol1-fundamentals/c_tutorials/02B-float-char-const-cast.md

@@ -316,17 +316,41 @@ C++ 在类型系统上做了大量的安全加固，很多改进直接瞄准了
 
 int main(void)
 {
-    double a = 0.1;
-    double b = 0.2;
-    double c = 0.3;
-
-    printf("a + b == c? %s\n", (a + b == c) ? "yes" : "no");
-    printf("a + b     = %.20f\n", a + b);
-    printf("c         = %.20f\n", c);
+    double a_double = 0.1;
+    double b_double = 0.2;
+    double c_double = 0.3;
+    float  a_float  = 0.1f;
+    float  b_float  = 0.2f;
+    float  c_float  = 0.3f;
+    float  e_float  = 0.3f;
+    float  f_float  = 0.4f;
+    float  g_float  = 0.7f;
+
+    printf("a_double + b_double == c_double? %s\n", (a_double + b_double == c_double) ? "yes" : "no");
+    printf("a_float + b_float   == c_float? %s\n", (a_float + b_float == c_float) ? "yes" : "no");
+    printf("e_float + f_float   == g_float? %s\n", (e_float + f_float == g_float) ? "yes" : "no");
+    printf("a_double + b_double   = %.20f\n", 0.1 + 0.2);
+    printf("a_float + b_float     = %.20f\n", 0.1f + 0.2f);
+    printf("e_float + f_float     = %.20f\n", 0.3f + 0.4f);
+    printf("c_double        = %.20f\n", c_double);
+    printf("c_float         = %.20f\n", c_float);
+    printf("g_float         = %.20f\n", g_float);
     return 0;
 }
 ```
 
+```text
+a_double + b_double   == c_double? no
+a_float + b_float     == c_float? yes
+e_float + f_float     == g_float? no
+a_double + b_double   = 0.30000000000000004441 //0.1 + 0.2
+a_float + b_float     = 0.30000001192092895508 //0.1f + 0.2f
+e_float + f_float     = 0.70000004768371582031 //0.3f + 0.4f
+c_double              = 0.29999999999999998890 //0.3
+c_float               = 0.30000001192092895508 //0.3f
+g_float               = 0.69999998807907104492 //0.7f
+```
+
 修改代码使用 epsilon 比较来得到正确的结果。
 
 ### 练习 2：隐式转换陷阱
@@ -345,6 +369,31 @@ if (target < sizeof(values) / sizeof(values[0])) {
 
 提示：`sizeof` 返回的是什么类型？
 
+
+### 练习 2 参考答案
+
+```c
+int values[] = {1, 2, 3, 4, 5};
+int target = -1;
+
+// bug 就在下面这行
+if (target < (int)sizeof(values) / (int)sizeof(values[0])) {
+    printf("target is in range\n");
+}
+```
+
+或者
+
+```c
+int values[] = {1, 2, 3, 4, 5};
+int target = -1;
+
+// bug 就在下面这行
+if (target < (int)(sizeof(values) / sizeof(values[0]))) {
+    printf("target is in range\n");
+}
+```
+
 ### 练习 3：const 实战
 
 写一个函数，接收一个字符串，统计其中某个字符出现的次数。函数签名中正确使用 `const`：
@@ -357,6 +406,23 @@ if (target < sizeof(values) / sizeof(values[0])) {
 size_t count_char(const char* str, char ch);
 ```
 
+### 练习 3 参考答案
+
+```c
+size_t count_char(const char* str, char ch) {
+    if (str == NULL) {  // 警惕空指针
+        return 0;
+    }
+    size_t count = 0;
+    for (;*str;str++) {
+        if (*str == ch) {
+            count++;
+        }
+    }
+    return count;
+}
+```
+
 ## 参考资源
 
 - [cppreference: C 语言隐式转换](https://en.cppreference.com/w/c/language/conversion)