L3：C 语言与内存模型

预处理 → 编译 → 汇编 → 链接 → 可执行文件

main.c
  │
  ├─ 预处理：展开 #include、#define
  │
  ├─ 编译：C 代码 → 汇编代码
  │
  ├─ 汇编：汇编代码 → main.o
  │
  └─ 链接：main.o + 其他 .o + 库 → 可执行文件

源代码 → 编译器/链接器 → 机器语言 → OS 加载 → 硬件直接执行

解释器本身是由高级语言编写，翻译成机器码程序
解释器读取 Python 源代码
解释器边读边解释执行

.java 源代码
   ↓ javac
.class 字节码
   ↓ JVM
解释执行 / JIT 编译成本地机器码

unsigned long udiv8(unsigned long x) {
    return x / 8;
}

return x >> 3;

long idiv8(long x) {
    return x / 8;
}

if (x < 0)
    x += 7;
return x >> 3;

-9 / 8 = -1   // C 语言向 0 截断
-9 >> 3 可能得到 -2

#include <stdio.h>
#include "file.h"
#define M_PI (3.14159)
#if
#endif

const float pi = 3.1415;
const unsigned long addr = 0xaf460;

typedef enum { red, green, blue } Color;
Color pants = green;

enum { red, green, blue };

red = 0
green = 1
blue = 2

sizeof(long long) >= sizeof(long) >= sizeof(int) >= sizeof(short)

char: 1
short: 2
int: 4
unsigned int: 4
long: 8
long long: 8
float: 4
double: 8

typedef int boolean;
const boolean false = 0;
const boolean true = 1;

int number_of_people() {
    return 3;
}

void news() {
    printf("no news");
}

int sum(int x, int y) {
    return x + y;
}

void undefined_local() {
    int x;  // undefined
    printf("x = %d\n", x);
}

typedef struct {
    int x, y;
} Point;

Point p1;
p1.x = 0;
p1.y = 123;

Point p2 = {77, -8};
printf("p2 at (%d,%d)\n", p2.x, p2.y);

Program 程序
Data 数据

printf("%d", a);

printf("%p", &a);

int *x;      // x 是一个指向 int 的指针
int y = 9;   // y 是一个 int

x = &y;      // 把 y 的地址赋给 x
int z = *x;  // 把 x 指向的值(9)赋给 z

*x = -7;     // 把 x 指向的东西（y）改成 -7

x = &y      // x 存着 y 的地址
y = -7
z = 9

int *pi;      // 指向 int 的指针
double *pd;   // 指向 double 的指针
char *pc;     // 指向 char 的指针

void *vp;

int a = 3;
double d = 1.5;

void *vp;

vp = &a;
vp = &d;

*vp

malloc
free

int *    ：我指向 int
double * ：我指向 double
char *   ：我指向 char
void *   ：我只知道我是地址，但不知道指向什么

typedef struct {
    int x, y;
} Point;

Point pt = {0, 5};

Point *pt_ptr = &pt;

pt 是一个 Point 结构体变量
pt_ptr 是一个指向 Point 的指针
pt_ptr = &pt 表示 pt_ptr 存放 pt 的地址

(*pt_ptr).x = (*pt_ptr).y;

pt_ptr->x = pt_ptr->y;

pt.x = 5
pt.y = 5

#include <stdio.h>

int main(void) {
    int a = 3, b = -7;
    int *pa = &a, *pb = &b;

    *pb = 5;

    if (*pb > *pa)
        a = *pa - b;

    printf("a=%d b=%d\n", a, b);
}

a = -2
b = 5

a = 3
b = -7
pa = &a
pb = &b

*pa == a == 3
*pb == b == -7

*pb = 5;

b = 5;

a = 3
b = 5
*pa = 3
*pb = 5

if (*pb > *pa)

if (5 > 3)

a = *pa - b;

a = 3 - 5 = -2

a = -2
b = 5

YELLOW：a = -2, b = 5

*pb = 5;

#include <stdio.h>

int main(void) {
    int a;
    int *p;

    printf("a = %d, p = %p, *p = %d\n", a, p, *p);

    return 0;
}

#include <stdio.h>

void f(int x, int *p) {
    x = 5;
    *p = -9;
}

int main(void) {
    int a = 1, b = -3;

    f(a, &b);

    printf("a=%d b=%d\n", a, b);
}

a = 1
b = -9

a = 1
b = -3

f(a, &b);

x = a 的值 = 1
p = b 的地址 = &b

x = 5;

a 仍然是 1

*p = -9;

b = -9;

a = 1
b = -9

f(a, b);

f(a, &b);

想让函数改外面的变量，就传它的地址。

基本类型 int, char, double：按值传递
对象 Objects：通过引用

#include <stdio.h>

void foo(int *x, int *y) {
    if (*x < *y) {
        int t = *x;
        *x = *y;
        *y = t;
    }
}

int main(void) {
    int a = 3, b = 1, c = 5;

    foo(&a, &b);
    foo(&b, &c);

    printf("a=%d b=%d\n", a, b);
}

YELLOW：a = 3, b = 5, c = 1

a = 3
b = 1
c = 5

foo(&a, &b);

x = &a
y = &b
*x = a = 3
*y = b = 1

if (*x < *y)

if (3 < 1)

a = 3
b = 1
c = 5

foo(&b, &c);

x = &b
y = &c
*x = b = 1
*y = c = 5

if (1 < 5)

int t = *x;

t = b = 1

*x = *y;

b = c = 5

*y = t;

c = 1

a = 3
b = 5
c = 1

YELLOW：a = 3, b = 5, c = 1

a = 3
b = 5
c = 1

p 是地址，*p 是地址里的东西。

int a[5];

int b[] = {3, 2, 1};

b[0] = 3
b[1] = 2
b[2] = 1

int a[] = {1, 2, 3};

for (int i = 0; i < 4; i++)
    printf("a[%d] = %d\n", i, a[i]);

a[0] = 1
a[1] = 2
a[2] = 3
a[3] = -1870523725

int i, ar[10];

for (i = 0; i < 10; i++) {
    ...
}

const int ARRAY_SIZE = 10;

int i, a[ARRAY_SIZE];

for (i = 0; i < ARRAY_SIZE; i++) {
    ...
}

char   通常 1 字节
short  通常 2 字节
int    通常 4 字节
double 通常 8 字节

char *z;
short *y;
int *x;

*z 取 1 个字节
*y 取 2 个字节
*x 取 4 个字节

double d;
int array[5];

struct {
    short a;
    char c;
} s;

double: 8
array: 20
s: 4

sizeof(char) == 1

sizeof(array)              // 整个数组的字节数，仅在数组还没退化成指针时有效
sizeof(array) / sizeof(array[0])  // 数组元素个数

char c[] = {'a', 'b'};
char *pc = c;

pc++;

*pc = b
c  = 0x...3e
pc = 0x...3f
pc - c = 1

pc - c

int i[] = {10, 20};
int *pi = i;

pi++;

*pi = 20
i  = 0x...40
pi = 0x...44
pi - i = 1

pi - i

p + 1 不是地址数值 + 1
而是地址数值 + sizeof(*p)

char *p; p + 1   移动 1 字节
int *p;  p + 1   移动 4 字节，假设 sizeof(int)=4
double *p; p + 1 移动 8 字节，假设 sizeof(double)=8

int a[3] = {10, 20, 30};

&a[0]

a[0] == *a
a[2] == *(a + 2)

char astr[] = "abc";
char *pstr = astr;

int n = 3;
int *p;

p += n;  // adds n * sizeof(int) to p
p -= n;  // subtracts n * sizeof(int) from p

p += 3;

3 * 4 = 12 字节

char *p;
char a, b;

p = &a;
p += 1;

a[i] ≡ *(a+i)

int foo(int array[]) {
    ...
}

int array[]

int *array

int foo(int array[], unsigned int size) {
    return array[size - 1];
}

int main(void) {
    int a[10], b[5];

    foo(a, 10);
    foo(b, 5);
}

C 函数收到数组参数时，收到的是首元素地址，不是整个数组信息。

int foo(int array[], unsigned int size) {
    printf("%d\n", sizeof(array));
}

int main(void) {
    int a[10];

    foo(a, 10);
    printf("%d\n", sizeof(a));
}

sizeof(int) == 4

sizeof(a)

10 * 4 = 40

sizeof(array)

void foo(int array[]) {
    sizeof(array); // 指针大小，不是数组大小
}

int i;
int array[5];

for (i = 0; i < 5; i++) {
    array[i] = ...;
}

int *p;
int array[5];

for (p = array; p < &array[5]; p++) {
    *p = ...;
}

array[i] 视角：第 i 个元素
*p 视角：当前指针指向的元素

const int SZ = 10;
int ar[SZ], *p, *q, sum = 0;

p = &ar[0];
q = &ar[SZ];

while (p != q) {
    sum += *p++;
}

q = &ar[SZ];

ar[SZ - 1]

&ar[SZ]

q = &ar[SZ];  // 可以
*q           // 不可以

数组末尾后一个位置可以拿来比较，但不能解引用。

1. 指针 + 整数
2. 指针 - 整数
3. 两个指针相减，但必须指向同一个数组中的元素
4. 比较指针：<, <=, ==, !=, >, >=
5. 指针和 NULL 比较

两个指针相加
指针相乘
整数 - 指针

int x = 10;
int *p = &x;
int **pp = &p;

x   是 int，值是 10
p   是 int*，存的是 x 的地址
pp  是 int**，存的是 p 的地址

pp ──> p ──> x ──> 10

int x[] = {2, 4, 6, 8, 10};

int *p = x;
int **pp = &p;

(*pp)++;
(*(*pp))++;

printf("%d\n", *p);

5

x[0] = 2
x[1] = 4
x[2] = 6
x[3] = 8
x[4] = 10

int *p = x;

p 指向 x[0]
*p = 2

int **pp = &p;

pp 指向 p
*pp 就是 p
**pp 就是 *p，也就是 x[0]

(*pp)++;

p++;

p 从指向 x[0] 变成指向 x[1]
*p = 4

(*(*pp))++;

*pp

*(*pp)

(*(*pp))++;

x[1]++;

x[1] 从 4 变成 5

printf("%d\n", *p);

*p = 5

5

char s[] = "abc";

s[0] = 'a'
s[1] = 'b'
s[2] = 'c'
s[3] = '\0'

char s[] = "abc";

字符串长度 strlen(s) 是 3
数组占用字符数是 4，因为还有 '\0'

str = abc, length = 3

strlen 不包含 '\0'
sizeof(str) 包含 '\0'

strlen(str) == 3
sizeof(str) == 4

int strlen(char *s) {
    char *p = s;

    while (*p++)
        ; /* Null body of while */

    return (p - s - 1);
}

while (*p++)

先取当前 p 指向的字符作为 while 条件
然后 p 往后移动一格

a b c \0

p 指向 'a'，*p++ 是 'a'，非 0，继续
p 指向 'b'，*p++ 是 'b'，非 0，继续
p 指向 'c'，*p++ 是 'c'，非 0，继续
p 指向 '\0'，*p++ 是 0，循环结束，但 p 已经又往后走了一格（这边涉及one-past-end）

return (p - s - 1);

int main(int argc, char *argv[])

argc 是命令行上的字符串数
argv 是一个指向数组的指针，数组中包含字符串形式的参数

argc = argument count，参数个数
argv = argument vector，参数数组

char *argv[]

argv 是一个数组
数组每个元素都是 char *
每个 char * 指向一个字符串

gcc -o ex Argc.c
./ex -g a "d e f"

arg[0] = ./ex
arg[1] = -g
arg[2] = a
arg[3] = d e f

argv[0] = ./ex

argv[1] = "-g"
argv[2] = "a"
argv[3] = "d e f"

argc = 4

./ex
-g
a
d e f

#include <stdio.h>

int main(int argc, char *argv[]) {
    for (int i = 0; i < argc; i++) {
        printf("arg[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

1. 指针是 C 语言里的机器内存地址
2. 指针变量保存在内存中，指针值本质上是可被软件操作的数字
3. C 中数组和指针关系非常密切
4. 指针知道它指向对象的类型和大小，void * 除外
5. 指针强大，但如果没有规划，会成为错误的主要来

数组与指针
├── 数组
│   ├── 下标从 0 开始
│   ├── 不检查越界
│   └── 不自带长度
├── sizeof
│   ├── 在 main 里 sizeof(a) 是整个数组
│   └── 在函数参数里 sizeof(array) 是指针大小
├── 指针运算
│   ├── p+1 移动 sizeof(*p) 字节
│   ├── 只建议在数组内使用
│   └── one-past-end 可比较，不可解引用
├── 数组/指针对偶
│   ├── a[i] == *(a+i)
│   ├── a 常退化成 &a[0]
│   └── 数组名不能 a++
└── 字符串
    ├── char 数组
    ├── 以 '\0' 结尾
    ├── strlen 不数 '\0'
    └── argv 是字符串数组

int main(void) {
    printf("hello\n");
}

free(main);

int global_x = 10;

static int count = 0;

程序启动时加载
可以修改
尺寸固定

int g = 1;

int main(void) {
    g = 2;
}

void f(int n) {
    int x = 5;
}

n 是函数参数
x 是局部变量

void a() {
    int a_local = 0;
    b(a_local);
}

int b(int arg) {
    int b_local = 5;
    return 2 * arg + b_local;
}

int main(void) {
    a();
    b(7);
}

Frame main
Frame a
Frame b

main 先放上去
a 再压上去
b 再压上去
b 返回，b 的盘子拿掉
a 返回，a 的盘子拿掉

#include <stdio.h>
#include <stdlib.h>

int x = 2;

int foo(int n) {
    int y;
    if (n <= 0) {
        printf("End case!\n");
        return 0;
    } else {
        y = n + foo(n - x);
        return y;
    }
}

int main(void) {
    foo(10);
}

#x = 1
#y = 6

int x = 2;

#x = 1

int foo(int n) {
    int y;
    ...
}

foo(10)
foo(8)
foo(6)
foo(4)
foo(2)
foo(0)

#x = 1
#y = 6

#include <stdio.h>
#include <math.h>

int *f() {
    int x = 5;
    return &x;
}

int main(void) {
    int *a = f();
    double d = cos(1.57);
    printf("a = %d\n", *a);
}

int x = 5;
return &x;

f 的栈帧被释放
x 不再有效

*a

a = -1085663214

int n;
scanf("%d", &n);
int *a = malloc(n * sizeof(int));

malloc()   分配一块未初始化的内存
calloc()   分配一块内存并初始化为 0
free()     释放先前分配的内存块
realloc()  更改先前分配块的大小

void *malloc(size_t n);

#include <stdlib.h>

int main(void) {
    int *ip = (int *)malloc(50 * sizeof(int));

    double *dp = malloc(1000 * sizeof(double));
}

malloc(50 * sizeof(int))

50 * 4 = 200 字节

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    const int SZ = 10;
    int *p = malloc(SZ * sizeof(int));
    int *end = &p[SZ];

    while (p < end)
        *p++ = 0;

    free(p);
}

free(p);

while (p < end)
    *p++ = 0;

p == &原数组[SZ]

pointer being freed was not allocated

不要把 malloc 返回的“原始句柄”弄丢。

void free(void *p);

int *p = malloc(10 * sizeof(int));
free(p);

int *p = malloc(10 * sizeof(int));
p++;
free(p);      // 错

int x;
free(&x);     // 错，x 在栈上，不是 malloc 来的

int a[5];
free(a);      // 错，a 是栈上数组，不是 malloc 来的

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    const int SZ = 10;
    int *array = malloc(SZ * sizeof(int));

    for (int *p = array; p < &array[SZ]; )
        *p++ = 0;

    free(array);
}

int *array = malloc(...);

int *p = array;

free(array);

C：你负责倒垃圾，忘了就堆满屋子。
Java/Python：有人帮你倒垃圾，但他什么时候进屋不完全由你决定。

空闲内存不足时，malloc() 返回 NULL

malloc 可能失败，失败时返回 NULL。

malloc(sizeof(Node))

int *p = malloc(...);

// complicated code

free(p);

int x;
int *p = &x;
// do not call free(p)

int a[5];
// do not call free(a)

malloc 来的，free 回去。
不是 malloc 来的，别 free。

code/static：系统管
stack：自动管
heap：你来管

int *p = malloc(4 * sizeof(int));
p[1000] = 1;

malloc 库维护一个空闲块链表
需要内存时，从空闲块里切一块出来
free 时，再放回空闲链表

内存碎片
长链条的块

为不同大小的对象保留单独的内存池

34 KB -> 64 KB
66 KB -> 128 KB

A 请求 34k
B 请求 66k
C 请求 35k
D 请求 67k

34k -> 64k
66k -> 128k
35k -> 64k
67k -> 128k

大块可以拆成两个一样大的 buddy
两个相邻空闲 buddy 可以合并回大块

realloc(p, size)

如果 p 为 NULL，realloc 行为类似 malloc
如果 size 为 0，realloc 行为类似 free
返回新内存块地址，而且很可能已经移动

int *ip;

ip = (int *) malloc(10 * sizeof(int));
/* always check for ip == NULL */

ip = (int *) realloc(ip, 20 * sizeof(int));
/* always check for ip == NULL */
/* contents of first 10 elements retained */

realloc(ip, 0); /* identical to free(ip) */

code        程序指令，启动时加载，不变
static data 全局/静态数据，启动时加载，可修改，大小固定
stack       局部变量/参数，函数调用时创建，返回时失效
heap        malloc/calloc/realloc 创建，free 释放，程序员负责

1. 不要返回局部变量地址。
2. malloc 后检查是否为 NULL。
3. malloc 出来的内存未初始化。
4. malloc 返回的原始地址要保存好。
5. free 必须传 malloc/calloc/realloc 返回的起始地址。
6. 没 malloc 就别 free。
7. malloc 和 free 要配对，否则泄漏。
8. realloc 可能移动内存，旧指针可能失效。

#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int *a = malloc(sizeof(int));
    // ...
    free(a);        // a no longer exists!

    int *b = malloc(sizeof(int));
    *b = 128;

    *a = 55;        // ERROR!

    printf("a=%d, b=%d (==128!)\n", *a, *b);
}

a=55, b=55 (==128!)

free(a);

int *b = malloc(sizeof(int));

a 和 b 可能指向同一块物理内存

*a = 55;

use-after-free：释放后继续使用

a = NULL;

*a = 55;

Segmentation fault: 11

a = NULL;

*a = 55;

与其让错误悄悄污染数据，不如让错误尽早暴露。

free(p);
p = NULL;

gcc -g DefensiveB.c
gdb a.out
(gdb) run

Program received signal SIGSEGV, Segmentation fault.
0x0000000100000f76 in main () at DefensiveB.c:11
11    *a = 55;

gcc -g DefensiveB.c

在哪个源文件、哪一行崩了

Segmentation fault 不要瞎猜。
用 gdb 跑，先定位崩在哪一行。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *a = malloc(10 * sizeof(int));
    int *b = a;       // b is an "alias" for a

    b[0] = 1;

    // work with a (or b) ... then increase size
    a = realloc(a, 1000 * sizeof(int));

    // yet another array
    int *c = malloc(10 * sizeof(int));

    c[0] = 3;
    b[0] = 2;

    printf("a[0]=%d, b[0]=%d, c[0]=%d\n", a[0], b[0], c[0]);
    printf("a = %p\n", a);
    printf("b = %p\n", b);
    printf("c = %p\n", c);
}

int *b = a;
a = realloc(a, 1000 * sizeof(int));

a 和 b 指向同一块堆内存

a 指向新位置
b 还指向旧位置

a[0]=1, b[0]=2, c[0]=2
a = 0x7fc53b802600
b = 0x7fc53b403140
c = 0x7fc53b403140

b[0] = 2;

realloc 之后，旧别名指针 b 不再可靠。
继续使用 b 是 bug。

数学模型很美，但机器不是数学。
高级语言很舒服，但机器执行有底层细节。
算法复杂度很重要，但真实性能还受内存系统影响。

int 不是数学里的整数。
float 不是数学里的实数。

(x + y) + z = x + (y + z)

(1e20 + -1e20) + 3.14  → 3.14
1e20 + (-1e20 + 3.14) → ??

-1e20 + 3.14 ≈ -1e20

1e20 + -1e20 = 0

机器数有范围、有精度。
不要把 int 当无限整数，不要把 float 当真实实数。

1. 程序出现高级语言模型解释不了的错误
2. 调优程序性能
3. 理解编译器做了什么优化、没做什么优化
4. 操作系统、编译器等系统软件实现
5. 分析或对抗恶意软件

访问 memory[i] 和 memory[j] 都差不多

typedef struct {
    int a[2];
    double d;
} struct_t;

double fun(int i) {
    volatile struct_t s;
    s.d = 3.14;
    s.a[i] = 1073741824; /* Possibly out of bounds */
    return s.d;
}

a[0]
a[1]
d

s.a[0]
s.a[1]

s.a[i] = 1073741824;

fun(0) → 3.14
fun(1) → 3.14
fun(2) → 3.1399998664856
fun(3) → 2.00000061035156
fun(4) → 3.14
fun(6) → Segmentation fault

i = 0,1：写的是 a[0], a[1]，d 没变
i = 2,3：写到了 d 的不同部分，d 被改坏
i = 6：写到更危险的位置，程序崩溃

数组越界不一定立刻崩。
它可能只是悄悄改坏旁边的数据。

s.a[2] = 1073741824;

fun(2) → 3.1399998664856
fun(3) → 2.00000061035156

fun(6) → Segmentation fault

越界访问的后果取决于内存布局。
内存布局又取决于系统、编译器、优化方式。

常数因素也很重要
精确操作计数也不能完全预测性能
代码写法可能造成 10 倍性能差异
优化要在多个层次进行：
算法、数据表示、过程、循环

程序如何编译和执行
如何测量性能、识别瓶颈
如何在不破坏模块化和通用性的情况下优化

真实性能 = 算法 + 编译器 + CPU + 缓存 + 内存访问模式 + 代码写法

void copyji(int src[2048][2048],
            int dst[2048][2048])
{
    int i, j;
    for (j = 0; j < 2048; j++)
        for (i = 0; i < 2048; i++)
            dst[i][j] = src[i][j];
}

void copyij(int src[2048][2048],
            int dst[2048][2048])
{
    int i, j;
    for (i = 0; i < 2048; i++)
        for (j = 0; j < 2048; j++)
            dst[i][j] = src[i][j];
}

copyji：81.8 ms
copyij：4.3 ms

int *ipr, *ipw;

void ReadMem() {
    int i, j;
    ipr = (int *) malloc(4 * sizeof(int));
    i = *(ipr - 1000);
    j = *(ipr + 1000);
    free(ipr);
}

void WriteMem() {
    ipw = (int *) malloc(5 * sizeof(int));
    *(ipw - 1000) = 0;
    *(ipw + 1000) = 0;
    free(ipw);
}

i = *(ipr - 1000);
j = *(ipr + 1000);

*(ipw - 1000) = 0;
*(ipw + 1000) = 0;

坑 B：使用不属于你的内存
坑 B2：数组/堆块越界写

void ReadMem(void) {
    int *ipr = malloc(4 * sizeof(*ipr));
    if (ipr == NULL) return;

    int i = ipr[0];
    int j = ipr[3];

    free(ipr);
}

int *pi;

void foo() {
    pi = malloc(8 * sizeof(int));
    ...
    free(pi);
}

void main() {
    pi = malloc(4 * sizeof(int));
    foo();
    ...
}

free(pi);

main malloc A
foo malloc B，覆盖 pi，A 泄漏
foo free B
A 仍然泄漏

主坑：坑 D，内存泄漏
副坑：所有权规划不清

int *plk = NULL;

void genPLK() {
    plk = malloc(2 * sizeof(int));
    ...
    plk++;
}

void FreeMemX() {
    int fnh = 0;
    free(&fnh);
}

void FreeMemY() {
    int *fum = malloc(4 * sizeof(int));
    free(fum + 1);
    free(fum);
    free(fum);
}

free(fum);

free(fum + 1);

坑 C：搞乱 malloc 返回的句柄
坑 G：非法 free

free(fum);
free(fum);

坑 G：重复 free
坑 B：使用/操作已释放内存

void FreeMemY(void) {
    int *fum = malloc(4 * sizeof(*fum));
    if (fum == NULL) return;

    ...

    free(fum);
    fum = NULL;
}

fum = NULL;

没有 malloc，就没有 free。
free 必须传 malloc 最初返回的地址。
同一块内存只能 free 一次。

void StringManipulate() {
    const char *name = "Safety Critical";
    char *str = malloc(10);
    strncpy(str, name, 10);
    str[10] = '\0';
    printf("%s\n", str);
}

char *str = malloc(10);

str[0] ~ str[9]

str[10]

str[10] = '\0';

str[10] 越界

坑 B：使用不属于你的内存
坑 H：字符串结尾 '\0' 没有预留空间

strncpy(str, name, 10);

"Safety Critical"

S a f e t y   C r i

printf("%s\n", str);

坑 B：越界读
坑 H：字符串没有正确以 '\0' 结尾

free(str);

坑 D：内存泄漏

void StringManipulate(void) {
    const char *name = "Safety Critical";

    char *str = malloc(11);
    if (str == NULL) return;

    strncpy(str, name, 10);
    str[10] = '\0';

    printf("%s\n", str);

    free(str);
}

10 个有效字符 + 1 个 '\0'

void StringManipulate(void) {
    const char *name = "Safety Critical";

    char *str = malloc(strlen(name) + 1);
    if (str == NULL) return;

    strcpy(str, name);
    printf("%s\n", str);

    free(str);
}

C 字符串的内存大小 = 字符数量 + 1 个 '\0'。

char *append(const char* s1, const char *s2) {
    const int MAXSIZE = 128;
    char result[128];
    int i = 0, j = 0;

    for (j = 0; i < MAXSIZE - 1 && j < strlen(s1); i++, j++) {
        result[i] = s1[j];
    }

    for (j = 0; i < MAXSIZE - 1 && j < strlen(s2); i++, j++) {
        result[i] = s2[j];
    }

    result[++i] = '\0';
    return result;
}

char result[128];

append 的栈帧存在
result 存在

append 的栈帧销毁
result 失效

return result;

return &result[0];

坑 F：返回栈内存地址
坑 B：使用不属于你的内存

result[i] = '\0';

result[++i] = '\0';

i = 5

result[5] = '\0';

result[++i] = '\0';

result[6]

坑 A：使用未初始化值
坑 H：字符串终止符位置错误

i = 127

i < MAXSIZE - 1

result[++i] = '\0';

result[128]

result[0] ~ result[127]

坑 B：数组越界写
坑 H：字符串结尾处理错误

void append(char *result, size_t maxsize,
            const char *s1, const char *s2) {
    size_t i = 0, j = 0;

    for (j = 0; i < maxsize - 1 && s1[j] != '\0'; i++, j++) {
        result[i] = s1[j];
    }

    for (j = 0; i < maxsize - 1 && s2[j] != '\0'; i++, j++) {
        result[i] = s2[j];
    }

    result[i] = '\0';
}

char buf[128];
append(buf, sizeof(buf), "hello", "world");

谁提供内存，谁管理内存。
append 只负责写，不负责分配。

char *append(const char *s1, const char *s2) {
    size_t len1 = strlen(s1);
    size_t len2 = strlen(s2);

    char *result = malloc(len1 + len2 + 1);
    if (result == NULL) return NULL;

    memcpy(result, s1, len1);
    memcpy(result + len1, s2, len2);
    result[len1 + len2] = '\0';

    return result;
}

char *s = append("hello", "world");
...
free(s);

主坑：坑 F，返回栈内存地址
副坑：坑 B，可能越界写
副坑：坑 H，字符串 '\0' 位置错误
副坑：坑 D，如果改成 malloc 版本，调用者必须 free

int* init_array(int *ptr, int new_size) {
    ptr = realloc(ptr, new_size * sizeof(int));
    memset(ptr, 0, new_size * sizeof(int));
    return ptr;
}

int* fill_fibonacci(int *fib, int size) {
    int i;
    init_array(fib, size);

    /* fib[0] = 0; */
    fib[1] = 1;

    for (i = 2; i < size; i++)
        fib[i] = fib[i-1] + fib[i-2];

    return fib;
}

ptr = realloc(ptr, new_size * sizeof(int));

旧地址不变
ptr 还是原来的地址

旧块释放
新块分配到另一个地址
ptr 指向新地址

init_array(fib, size);

init_array 里的 ptr 指向新地址
fill_fibonacci 里的 fib 仍然是旧地址

fib[1] = 1;

坑 E：realloc 后旧指针失效
坑 B：访问已释放/不属于你的内存

int *fib = NULL;
fill_fibonacci(fib, size);

ptr = realloc(NULL, size * sizeof(int));

fib[1] = 1;

NULL[1] = 1;

坑 B：使用 NULL 指针
坑 E：没有正确接收 realloc 返回的新地址

ptr = realloc(ptr, new_size * sizeof(int));
memset(ptr, 0, new_size * sizeof(int));

memset(ptr, 0, ...)

memset(NULL, 0, ...)

ptr = realloc(ptr, ...)

坑 D：可能泄漏
坑 B：可能使用 NULL
坑 E：realloc 处理不当

fib[1] = 1;

坑 B：数组越界写

int* init_array(int *ptr, int new_size) {
    int *tmp = realloc(ptr, new_size * sizeof(*ptr));
    if (tmp == NULL) {
        return NULL;
    }

    memset(tmp, 0, new_size * sizeof(*tmp));
    return tmp;
}

int* fill_fibonacci(int *fib, int size) {
    if (size <= 0) return fib;

    fib = init_array(fib, size);
    if (fib == NULL) return NULL;

    fib[0] = 0;

    if (size > 1) {
        fib[1] = 1;
    }

    for (int i = 2; i < size; i++) {
        fib[i] = fib[i-1] + fib[i-2];
    }

    return fib;
}

fib = fill_fibonacci(fib, size);

主坑：坑 E，realloc 可能移动内存
副坑：坑 B，旧指针可能访问已释放内存
副坑：坑 D，realloc 失败可能泄漏
副坑：坑 B，size < 2 时越界
副坑：C 参数按值传递，函数里改 ptr 不会自动改外面的 fib

realloc 的返回值必须接住，而且要用新地址继续操作。

static List<Object> list = new ArrayList<>();

void f() {
    Object obj = new Object();
    list.add(obj);
}

这些对象还能被访问
不能回收

坑 D 的 Java 版本：逻辑上不用了，但引用还在，GC 无法回收

1. 使用无效参数调用 free
2. 访问已释放内存
3. 数组越界访问
4. 访问未分配内存，忘记 new

free(&局部变量)
free(p + 1)
double free

Java 仍可能泄漏，但少了很多 C 里会静默损坏内存的坑。

Java 仍有：坑 D，内存泄漏
Java 大幅避免：坑 B、坑 C、坑 E、坑 G

我们怎样才能除掉苹果树？

        10
       /  \
      5    16
          /
         11

free(root);

5、16、11 这些节点还在堆上

坑 D：内存泄漏

void free_tree(Node *root) {
    free(root);
    free_tree(root->left);
    free_tree(root->right);
}

free(root);

root->left
root->right

坑 B：访问已释放内存

void free_tree(Node *root) {
    if (root == NULL) {
        return;
    }

    free_tree(root->left);
    free_tree(root->right);

    free(root);
}

先释放 left
再释放 right
最后释放 root

root->left
root->right

Node *root = NULL;
insert(10, &root);
insert(5, &root);
...

free_tree(root);
root = NULL;

root->key

void destroy_tree(Node **rootp) {
    if (rootp == NULL || *rootp == NULL) {
        return;
    }

    Node *root = *rootp;

    destroy_tree(&root->left);
    destroy_tree(&root->right);

    free(root);
    *rootp = NULL;
}

destroy_tree(&root);

主坑：坑 D，树节点不释放会泄漏
副坑：坑 B，释放根后再访问孩子是 use-after-free
对应原则：谁 malloc，谁规划 free；复杂结构要递归释放

C 内存错误的本质不是“不会写 malloc/free”，
而是没搞清楚：这块内存是谁的、现在还活着吗、原始地址还在吗、谁负责释放。