在纸上写 C 代码

像计算机一样读代码

学完你能 你能一行一行地手动运行一小段 C 程序，并写下它用到的每一个值。

在纸上写代码时，没有任何东西会告诉你某一行写错了。你唯一的检查办法，是自己把程序运行一遍：一半在脑子里，一半写在纸上。这叫手动跟踪（英文叫 dry run）：你扮演计算机，拿着笔，一行一行地运行程序。

计算机不知道你的程序是做什么用的。它严格按每一行写的内容，按顺序执行，并且只记得变量里存着的东西。变量就是一个有名字的位置，里面存着一个值。你在跟踪时也要这样做：按这一行实际写的内容去做，而不是按你原本想写的内容去做。

用的工具叫跟踪表。跟踪表里每个变量占一列，每执行一行代码占一行。分四步来做。

1. 在页边给程序的每一行编号，从 1 开始。
2. 画表格。第一列是“行号”，接着每个变量一列，最后一列叫“备注”，用来写发生了什么，例如“条件为真”，或者程序输出了什么。
3. 开始运行。每执行一行，就加一行记录：先写行号，再写这一行执行完之后每个变量的值。没有变化的值要从上一行抄下来，这样每一行单独看也能读懂。
4. 对没有值的变量，用两种记号。短横线（–）表示这个变量还不存在，问号（?）表示它已经存在，但还没有存进任何值。正确的 C 程序不会去读一个仍然是问号的变量。

循环语句会执行很多次，所以会有很多行记录。对于 for 循环，每当计算机走到条件判断，就加一行：写下更新部分（例如 i++）之后各变量的值，并在备注里写条件判断的结果。循环的最后一行记录，是条件为假的那一次，这之后循环体不会再执行。在 for 括号里声明的变量（例如 i）在循环结束后就不存在了，所以之后要写短横线。

if 语句只占一行记录。如果条件为假，下一行记录就是这个 if 右花括号之后的第一行代码。

如果程序调用了函数，就为这次调用另画一张小表，列出它的参数和它自己的变量，并给每次调用编号（f#1、f#2）。函数返回时，把返回值写在发起调用的那一行的备注里。

#include <stdio.h>

int main(void) {
    int total = 0;
    for (int i = 1; i <= 4; i++) {
        if (i % 2 == 0) {
            total = total + i;
        }
    }
    printf("%d\n", total);
    return 0;
}

6

/* meant: run the body 3 times */
for (int i = 0; i <= 3; i++) {
    printf("*");
}

/* runs the body 3 times */
for (int i = 0; i < 3; i++) {
    printf("*");
}

double half = 7 / 2;

double half = 7 / 2.0;

int i = 3;
int a = i++;

int i = 3;
i++;
int a = i;

a = b;
b = a;

int t = a;
a = b;
b = t;

画出内存

学完你能 你能用一套固定的画法，画出 C 程序在任意一行时的栈、堆和静态数据区，并说出 free 会让图发生什么变化。

只看代码，是看不懂带指针的程序的。你需要一张图，说明每个值放在哪里、每个指针指向哪里。在纸上，这张图就是指针版的跟踪表。每次都用同一种画法，出错就会少很多。

C 把值放在三个地方。把它们画成三列，每列写一个标题：静态数据区、栈、堆。

静态数据区放整个运行期间都存在的东西：字符串字面量（例如 "hi"）和全局变量。写成字面量的文字是只读的，往里面写数据是错误。

栈为当前正在运行的每个函数放一个栈帧。栈帧是一个方框，里面放这个函数的参数和局部变量。先画 main 的栈帧，放在栈这一列的最上面。每调用一次函数，就在它下面加一个新栈帧。函数返回时，把它的栈帧划掉，里面的东西全部消失。

堆放你用 malloc 要来的内存块。内存块会一直存在，直到你对它调用 free。它不属于任何一个函数的栈帧。

下面是画图的规则。

1. 变量是一个小方框。类型和名字写在旁边，值写在里面，例如 int n 和 3。还没有值的变量里写 ?。
2. 指针也是一个方框，它的值是一支箭头。箭头从方框里出发，指向它所指的东西。同时在方框里写上目标的标签，这样箭头交叉时你仍然能读出来。
3. 给每个堆内存块加标签：H1、H2、H3，按 malloc 被调用的顺序编号。在块的上方写标签、类型和大小，例如 H1 (int[3])。块里的每个单元画成一个带下标的方框：[0]、[1]、[2]。真实地址每次运行都会变，所以图里改用标签。
4. 赋值是复制方框里的内容。p = q 复制的是箭头，不是内存块。执行 int *q = p; 之后，有两个带箭头的方框，但内存块仍然只有一个。
5. 字符串是一个 char 数组，最后一格存 '\0'。char s[] = "hi" 在栈帧里画一个三格的数组。char *t = "hi" 在栈帧里画一个指针，它的箭头指向静态数据区里的只读文字。

free 会让图发生什么变化。free(p) 释放 p 所指的内存块。在纸上这样画：在内存块上打一个大叉，写上 freed。p 方框里的箭头和标签不要改，因为 free 不会改变 p。所有仍然带着这个标签的指针现在都是悬空指针：它们指向你已经不再拥有的内存。通过悬空指针读或写，是未定义行为，意思是语言对程序会发生什么不作任何保证。对同一个块调用两次 free 也是未定义行为。free(p) 之后写 p = NULL;，并在 p 的方框上画一道斜线。NULL 是不指向任何东西的指针值，free(NULL) 什么也不做。

泄漏是指：一个内存块从未被释放，而且图里已经没有任何箭头能到达它。在 main 的最后一行，检查每一个块。如果它上面没有叉，也没有箭头指向它，它就泄漏了。

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

int *make(int n) {
    int *a = malloc(n * sizeof(int));
    if (a == NULL) {
        return NULL;
    }
    for (int i = 0; i < n; i++) {
        a[i] = (i + 1) * 10;
    }
    return a;
}

int main(void) {
    int *p = make(3);
    if (p == NULL) {
        return 1;
    }
    int *q = p;
    q[1] = 99;
    /* A: draw the memory here */
    printf("%d %d %d\n", p[0], p[1], p[2]);
    free(p);
    p = NULL;
    /* B: draw the memory here */
    return 0;
}

10 99 30

int *q = p;

p [H1] ----> H1 (int[3]) | 10 | 20 | 30 |
q [H2] ----> H2 (int[3]) | 10 | 20 | 30 |

int *q = p;

p [H1] ----+
           v
           H1 (int[3]) | 10 | 20 | 30 |
           ^
q [H1] ----+

free(p);

p [NULL]
H1 (int[3]) | 10 | 20 | 30 |

free(p);

p [H1] ----> H1 (int[3]) FREED
             |  X  |  X  |  X  |
p is now dangling; write p = NULL

char *s = "hi";
s[0] = 'H';

char s[] = "hi";
s[0] = 'H';

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

int good(void) {
    int x = 5;
    return x;
}

要背熟的语法

学完你能 你能凭记忆写出下面八个 C 骨架，从最短的开始，每个分号和括号都不缺。

有些代码没法当场推出来，你必须不看资料就知道它的形状。这一课的八个骨架，是 C 里反复要用的。它们都很短，可以背下来。按下面的顺序学，从最短的开始，上一个背牢了，再加下一个。

1. 头文件包含。2. main。3. 函数。4. for 循环。5. 带 typedef 的 struct。6. 带 NULL 检查的 malloc，以及 free。7. 字符串函数。8. printf 的格式符。

背诵的办法：盖住页面，在纸上默写这个骨架，再和页面逐个字符对照。只有完全对、中途没有偷看，才打勾。明天再来一遍。连续三天都能写对的骨架，才算学会。

下面的程序包含全部八个骨架，每个骨架旁边有一条形如 (1) 的注释。先读一遍，再盖住它，在你自己的纸上把每个骨架单独默写出来，每个只写几行。

字符串函数：目标总是放在第一个，就像等号的左边。strcpy(dest, src) 把 src 复制到 dest。strcat(dest, src) 把 src 接在 dest 的末尾。strncpy(dest, src, n) 和 strncat(dest, src, n) 把限制长度 n 放在最后一个参数。要小心：当 src 有 n 个字符或更多时，strncpy 不会写入 '\0'。strcmp(a, b) 在两个字符串相等时返回 0，a 排在 b 前面时返回负数，a 排在 b 后面时返回正数。因为 0 表示相等，所以要写成 strcmp(a, b) == 0。strlen(s) 返回不含 '\0' 的长度。目标数组必须已经有足够的空间，放得下文字和 '\0'。

printf 的格式符：%d 是 int，%u 是 unsigned int，%ld 是 long，%zu 是 size_t（strlen 的返回类型），%f 是 double，%.2f 是保留两位小数的 double，%c 是一个 char，%s 是字符串，%p 是指针，%x 是十六进制的 unsigned int，%% 是百分号。每个格式符都需要一个类型匹配的参数，顺序也要一致。

/* (1) includes */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* (5) struct with typedef */
typedef struct {
    char name[20];
    int score;
} Player;

/* (3) a function */
int add(int a, int b) {
    return a + b;
}

/* (2) main */
int main(void) {
    /* (4) for */
    int total = 0;
    for (int i = 0; i < 3; i++) {
        total = add(total, i);
    }

    Player p;
    strcpy(p.name, "Mia");
    p.score = total;

    /* (6) malloc, NULL check, free */
    int *a = malloc(3 * sizeof(int));
    if (a == NULL) {
        return 1;
    }
    for (int i = 0; i < 3; i++) {
        a[i] = i * 10;
    }

    /* (7) string functions */
    char word[20];
    strcpy(word, "hello");
    strcat(word, "!");
    if (strcmp(word, "hello!") == 0) {
        /* (8) printf specifiers */
        printf("%s %d %c %.2f %zu\n", p.name, p.score, word[0], 3.14159, strlen(word));
    }

    free(a);
    return 0;
}

Mia 3 h 3.14 6

char buf[10];
strcpy("hi", buf);

char buf[10];
strcpy(buf, "hi");

if (strcmp(a, b)) {
    printf("same\n");
}

if (strcmp(a, b) == 0) {
    printf("same\n");
}

printf("%d %s\n", 3.5, 'a');

printf("%f %c\n", 3.5, 'a');

int *a = malloc(3);

int *a = malloc(3 * sizeof(int));

手写时常见的错误

学完你能 你能把自己写的 C 答案像编译器那样再读一遍，抓住本来会丢分的小错。

在计算机上，编译器会在第一个漏掉的分号处拦住你。在纸上，没有人拦你，而这些小错每一个都会丢分，尽管它们和你是否理解题目毫无关系。所以你必须自己当自己的编译器。

答案写完之后，再读第二遍。这一遍不要问逻辑对不对，只问形式对不对。照下面的清单，用笔逐项打勾。

1. 每条语句都以分号结尾。struct 的定义在右花括号后面也要有分号。
2. 每个 ( [ { 都有配对的另一半。把花括号成对地数一遍。
3. 每个变量在使用之前都已声明，并且带着类型。
4. 用到的每个库函数都写了头文件。
5. = 是存入一个值，== 是提出一个问题。检查每一个 if 和 while。
6. 字符串用双引号，单个字符用单引号。
7. 每个 printf 格式符都有类型正确的参数。
8. 数组下标从 0 到 n - 1。n 个字符的字符串需要 n + 1 格。
9. 点用来访问结构体变量的字段，箭头用来通过指针访问字段。
10. for 或 while 那一行的圆括号后面不能有分号。

下面是最容易丢分的四组错误。每组里第一块是常见的错误写法，第二块是改正后的写法。

typedef struct {
    int x;
    int y;
} Point

for (int i = 0; i < 3; i++);
{
    printf("%d\n", i);
}

typedef struct {
    int x;
    int y;
} Point;

for (int i = 0; i < 3; i++) {
    printf("%d\n", i);
}

if (n = 0) {
    printf("empty\n");
}
char c = "a";

if (n == 0) {
    printf("empty\n");
}
char c = 'a';

Node *p = head;
printf("%d\n", p.value);
int n;
scanf("%d", n);

Node *p = head;
printf("%d\n", p->value);
int n;
scanf("%d", &n);

char s[3] = "abc";
if (s == "abc") {
    printf("same\n");
}

char s[4] = "abc";
if (strcmp(s, "abc") == 0) {
    printf("same\n");
}

给自己打分

学完你能 你能对照评分标准诚实地给自己的手写答案打分，找出分数丢在哪里，安排明天的练习，并在限时下写代码。

在纸上，一页写满的答案看起来像是完成了，其实可能是错的。给自己打分能解决这个问题。你拿答案去对照评分标准。评分标准是一组条目，每条值若干分，每条描述一件你能在答案里看到的东西。要严格。真正算数的分数，是一个陌生人会给你的分数。

怎样逐条读评分标准。

1. 读一条。问自己：一个正确的答案里，我到底会看到什么？
2. 在你的答案里找到那样东西，用笔尖点住它。指得出来，就打勾并写下这条的分数；指不出来，这一条就是零分。
3. “差不多”不给半分。只有评分标准写明怎么拆分时，才给一条的部分分数。
4. 检查每一条路径。像“释放内存块”这样的条目，只要你的代码里有一条路线（例如提前 return）跳过了 free，就是零分。
5. 把各条加起来，把总分写成“得分/满分”的形式放在页面上。

怎样找出分数丢在哪里。把每一个丢掉的分放进四个格子之一。思路：我不知道怎么解。记忆：我知道，但记不起语法或函数。小错：在我本来会的东西上犯的小错误，例如漏了分号或写错了符号。时间：我没写完。数一数每个格子。最大的格子告诉你该练什么。思路：重读对应的课。记忆：多做“盖住再默写”。小错：用上一课的编译器检查清单，再加一个很小的测试。时间：练习先做计划。

第二天要做什么。第一，在空白页上不看资料，把同一道题的答案重写一遍。第二，做一道同类型的不同题目。第三，把两份答案再各打一次分。三天后和一周后再重复。当最大的格子换了，说明你在进步。

怎样在限时下写。

1. 先做计划。用掉最初的十分之一时间。写出函数头，再写三四行说明步骤的注释。不要跳过这一步。
2. 代码行之间空一行。你会需要空间补写漏掉的一行。
3. 变量名要清楚：用 count，不要用 c；用 head，不要用 h。名字清楚，就不会把两个变量混在一起。
4. 用一个很小的输入手算测试。代码写完后，用最小的情况走一遍：只有一个元素、空字符串、n 等于 1。这只要一分钟，却能找出大部分边界错误。
5. 大约每分花一分钟。某一部分卡住了，就写一行注释说明你打算怎么做，然后往下写，回头再补。
6. 留出两分钟做编译器检查。

在“练习”页面里，题型为“手写代码”的题目有手写模式：有计时器、参考答案，以及可以打勾的评分标准。完全按这一课的办法用它：先在纸上写，再打分。

#include <stdio.h>

/* A student's answer. It has one bug. */
int smallest(const int *a, int n) {
    int best = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] < best) {
            best = a[i];
        }
    }
    return best;
}

int main(void) {
    int test[] = {5, 3, 8};
    printf("%d (expected 3)\n", smallest(test, 3));
    return 0;
}

0 (expected 3)

for (int i = 1; i < n - 1; i++) {
    if (a[i] < best) {
        best = a[i];
    }
}

for (int i = 1; i < n; i++) {
    if (a[i] < best) {
        best = a[i];
    }
}

int sum;
for (int i = 0; i < n; i++) {
    sum = sum + a[i];
}

int sum = 0;
for (int i = 0; i < n; i++) {
    sum = sum + a[i];
}

int total(const int *a, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum = sum + a[i];
    }
    printf("%d\n", sum);
}

int total(const int *a, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum = sum + a[i];
    }
    return sum;
}