C 语言入门：从第一个程序到指针

源代码、编译、运行：第一个程序

学完你能 学完这课，你能写出一个小的 C 程序，编译并运行它，并说清楚源代码、编译和运行各是什么意思。

电脑会按指令办事。编程语言是让人能读懂的写指令的方式。C 就是其中一种。它历史悠久、小巧而且很快，很多操作系统都是用它写的。

让一个 C 程序跑起来有三步，每一步都有名字。

源代码是你写的文字。你把它保存在一个纯文本文件里，文件名以 .c 结尾，例如 hello.c。电脑不能直接照着这段文字去做。

编译是把源代码翻译成机器码，也就是处理器能执行的数字。负责翻译的工具叫编译器。它读入 hello.c，写出一个新文件，这个文件叫可执行文件，是电脑可以运行的文件。编译时，编译器还会检查你的文字，发现严重的错误就会停下来。

运行是让电脑去执行这个可执行文件。程序打印出结果，然后结束。

这个循环你会重复很多次：修改源代码，编译，运行。如果你改了源代码却忘了编译，运行的就还是旧程序。

每个 C 程序都从一个叫 main 的函数开始。函数是一组有名字的指令。下面例子的第一行是 #include，它引入 printf 的说明，printf 是用来打印文字的函数。花括号 { } 标出 main 从哪里开始、到哪里结束。里面每一条指令叫语句，语句以分号结尾。

在自己的电脑上，你要在终端里做这些事。现在只需要四条命令。想看看你现在在哪个文件夹，输入：
pwd
想列出这个文件夹里的文件，输入：
ls
想新建一个叫 c-practice 的文件夹，输入：
mkdir c-practice
想进入这个文件夹，输入：
cd c-practice

每条命令输入后按回车键。接着用 nano 创建文件，nano 是在终端里运行的编辑器：
nano hello.c
输入程序，同时按 Ctrl 和 O 再按回车键来保存，同时按 Ctrl 和 X 退出。任何纯文本编辑器都可以用。不要用文字处理软件，因为它会加入看不见的格式。然后编译并运行：
cc -std=c11 -Wall -Wextra hello.c -o hello
./hello

这里 cc 是编译器，hello.c 是源代码，-o hello 的意思是“把可执行文件命名为 hello”。请特别小心：-o 后面的名字是编译器要创建的文件，同名文件会被它覆盖。千万不要把你的 .c 文件写在那里。选项 -Wall 和 -Wextra 让编译器指出可疑的代码，第 8 课会解释。./hello 的意思是“当前文件夹里叫 hello 的程序”。如果编译这一行没有打印任何东西，就说明成功了。

你也可以直接点下面例子的“运行”按钮，它会在页面里帮你完成编译和运行。

// hello.c: my first program
#include <stdio.h>

int main(void) {
    printf("Hello, Leon!\n");
    printf("This program ran.\n");
    return 0;
}

Hello, Leon!
This program ran.

printf("Hello, Leon!\n")
return 0;

printf("Hello, Leon!\n");
return 0;

hello

./hello

printf("Hello, Leon!");

printf("Hello, Leon!\n");

(edit hello.c, save it)
./hello

cc -std=c11 -Wall -Wextra hello.c -o hello && ./hello

printf 与格式说明符：打印数值

学完你能 学完这课，你能用 printf 打印数字、字母和文字，并为每种值选对格式说明符。

printf 用来打印文字。你给它的第一样东西是格式字符串，也就是双引号里的一段文字。其中大部分内容会按原样打印。但是百分号后面跟一个字母，是一个占位符，叫格式说明符。printf 会按顺序，把每个占位符换成格式字符串后面列出的下一个值。

例如，下面这行会打印 Leon is 20 years old：
printf("Leon is %d years old\n", 20);
其中 %d 是整数的占位符，20 是填进去的值。格式字符串后面的这些值叫实参。

下面这些说明符能满足大部分需求：
%d 整数（类型 int）
%f 带小数点的数（类型 double）。写成 %.2f 会精确显示小数点后两位。
%c 一个字符，例如 A
%s 字符串，也就是 Mia 这样的文字
%x 十六进制的整数。十六进制是 16 进制，数字用 0 到 9 和 a 到 f。数字 255 会打印成 ff。
%zu 一个大小，也就是 sizeof 产生的那种数（第 3 课）
%% 百分号本身

你可以在 % 和字母之间加一个宽度。%5d 会用空格把数字补到至少 5 个字符宽，%-5d 效果相同，但数字靠左。

说明符必须与值匹配。printf 无法检查值的类型，它只会相信你。如果你写了 %d，却传入带小数的数，输出就是无意义的结果，只有编译器的警告（第 8 课）才能发现。占位符的个数也必须等于值的个数。

引号里的特殊字符以反斜杠开头，这叫转义序列。\n 是换行，\t 是制表符，\" 是引号本身，\\ 是反斜杠本身。

双引号表示文字。单引号表示一个字符：'A' 是字母 A，而 "A" 是一段文字。第 3 课和第 6 课还会回到这一点。

#include <stdio.h>

int main(void) {
    int apples = 3;
    double price = 2.5;
    char grade = 'A';

    printf("Leon bought %d apples.\n", apples);
    printf("Each costs %.2f, so the total is %.2f.\n", price, apples * price);
    printf("Grade: %c\n", grade);
    printf("Name: %s\n", "Mia");
    printf("Hex: %x, character code: %d\n", 255, grade);
    printf("Padded: [%5d] [%-5d]\n", 42, 42);
    printf("Ratio: 50%%\n");
    printf("A quote \" and a backslash \\\n");
    return 0;
}

Leon bought 3 apples.
Each costs 2.50, so the total is 7.50.
Grade: A
Name: Mia
Hex: ff, character code: 65
Padded: [   42] [42   ]
Ratio: 50%
A quote " and a backslash \

printf("%d\n", 2.5);

printf("%f\n", 2.5);

printf("%d and %d\n", 7);

printf("%d and %d\n", 7, 8);

printf('Hello\n');

printf("Hello\n");

printf("Sale: 50% off\n");

printf("Sale: 50%% off\n");

变量、类型与大小

学完你能 学完这课，你能声明变量，在 int、double 和 char 中选择合适的类型，读懂简单的算术表达式，并查出一个类型占几个字节。

变量是电脑内存里一个有名字的盒子，里面放一个值。你通过声明来创建变量：先写类型，再写名字，通常还要写一个初始值。
int count = 7;

类型说明盒子里能放哪种值，以及盒子有多大。现在你需要三种类型。int 是整数，例如 -3、0 或 42。double 是带小数点的数，例如 3.14。char 是一个字符，例如 'A'，用单引号写。

符号 = 的意思是赋值。它先算出右边，再把结果存进左边的盒子里。它不是数学里的“等于”。语句 count = count + 1 的意思是“取出 count 里的值，加一，再存回去”。语句 count += 2 是 count = count + 2 的简写。

变量一定要给初始值。一个从没被填过的盒子里是遗留的位，读取它会得到不可预测的结果。

表达式是一段能算出一个值的代码，例如 2 + 3 * 4。读表达式时，先找出哪一部分最先被计算。括号最先。然后是 *、/ 和 %（乘、除、取余），再然后是 + 和 -。同一级的运算符从左到右算。所以 2 + 3 * 4 是 14，而 (2 + 3) * 4 是 20。拿不准时，就加括号。

有两个陷阱。第一，int 除以 int 得到 int，小数部分会被丢掉。所以 7 / 2 是 3。% 运算符给出余数，所以 7 % 2 是 1。如果你想要 3.5，就让其中一边是 double，写成 7 / 2.0。第二，int 的范围有限，大约是负 20 亿到正 20 亿。头文件 limits.h 提供 INT_MAX，也就是最大的 int。超过它属于未定义行为，意思是语言对会发生什么完全不作保证。

内存以字节为单位计算。位是单个的 0 或 1，字节是一组位，在普通电脑上是 8 位。运算符 sizeof 给出一个类型或变量占多少字节。在普通电脑上，char 占 1，int 占 4，double 占 8。limits.h 里的常量 CHAR_BIT 就是一个字节有多少位。

char 是以一个小整数的形式保存的：'A' 是 65。所以 'A' + 1 是 66，也就是 'B' 的编码。

#include <stdio.h>
#include <limits.h>

int main(void) {
    int count = 7;
    double ratio = 7.0 / 2;
    char letter = 'A';

    printf("count = %d, ratio = %.1f\n", count, ratio);
    printf("7 / 2 = %d, 7 %% 2 = %d, 7 / 2.0 = %.1f\n", 7 / 2, 7 % 2, 7 / 2.0);
    printf("2 + 3 * 4 = %d, (2 + 3) * 4 = %d\n", 2 + 3 * 4, (2 + 3) * 4);

    count = count + 1;
    count += 2;
    printf("count is now %d\n", count);

    printf("letter %c has code %d, and letter + 1 is %c\n", letter, letter, letter + 1);
    printf("sizes: char %zu, int %zu, double %zu\n", sizeof(char), sizeof(int), sizeof(double));
    printf("bits in a byte: %d, largest int: %d\n", CHAR_BIT, INT_MAX);
    return 0;
}

count = 7, ratio = 3.5
7 / 2 = 3, 7 % 2 = 1, 7 / 2.0 = 3.5
2 + 3 * 4 = 14, (2 + 3) * 4 = 20
count is now 10
letter A has code 65, and letter + 1 is B
sizes: char 1, int 4, double 8
bits in a byte: 8, largest int: 2147483647

double half = 1 / 2;

double half = 1 / 2.0;

int total;
total = total + 5;

int total = 0;
total = total + 5;

char letter = "A";

char letter = 'A';

int big = 2147483647;
big = big + 1;

int big = 2147483647;
if (big < INT_MAX) {
    big = big + 1;
}

判断与重复：if 和循环

学完你能 学完这课，你能用 if 让程序做选择，用 for 和 while 重复工作，并读懂控制它们的条件。

程序通常按从上到下的顺序执行语句。if 语句和循环语句会改变这个顺序。

条件是一个要么真要么假的表达式。C 里的条件没有单独的“真”和“假”：数字 0 表示假，任何其他数字都表示真。比较运算符的结果，真是 1，假是 0。它们是 <（小于）、<=（小于或等于）、>（大于）、>=（大于或等于）、==（等于）和 !=（不等于）。请注意：== 是比较两个值，而单独一个 = 是存入一个值。

条件可以用 &&（并且：两边都为真）、||（或者：至少一边为真）和 !（非）组合起来。&& 和 || 都会提前停止：如果左边已经能决定答案，右边就不会被检查。这叫短路求值。

if 语句只在条件为真时才运行一个代码块。代码块是花括号里的一组语句。你可以用 else 处理另一种情况，用 else if 处理更多情况。

循环会重复一个代码块。while 循环先检查条件，只要条件为真就一直重复。for 循环的括号里有三个部分：初始设置、条件和步进。
for (int i = 0; i < 3; i++)
它的意思是：让 i 从 0 开始，只要 i 小于 3 就继续，每轮结束后把 i 加 1。表达式 i++ 的意思是 i = i + 1。所以代码块在 i 等于 0、1 和 2 时各运行一次，一共三次。在 C 里从 0 开始计数是常态。代码块每运行一遍叫一次迭代。

循环里必须有某个因素最终让条件变成假。如果没有，它就永远不会结束。这时在终端里同时按 Ctrl 和 C 来停止它。break 语句立即离开循环。continue 语句跳到下一次迭代。

每个代码块都要用花括号括起来，即使里面只有一条语句。这样能避免一整类错误。

#include <stdio.h>

int main(void) {
    int total = 0;
    for (int i = 1; i <= 6; i++) {
        if (i % 2 == 0) {
            total += i;
            printf("%d is even, total is %d\n", i, total);
        } else {
            printf("%d is odd, skipped\n", i);
        }
    }

    int coins = 1;
    int days = 0;
    while (coins < 100) {
        coins = coins * 2;
        days++;
    }
    printf("coins reach %d after %d days\n", coins, days);

    int age = 17;
    if (age >= 13 && age < 20) {
        printf("age %d is a teenager\n", age);
    }
    return 0;
}

1 is odd, skipped
2 is even, total is 2
3 is odd, skipped
4 is even, total is 6
5 is odd, skipped
6 is even, total is 12
coins reach 128 after 7 days
age 17 is a teenager

int x = 3;
if (x = 5) {
    printf("five\n");
}

if (x == 5) {
    printf("five\n");
}

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

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

if (1 < x < 5) {
    printf("between\n");
}

if (1 < x && x < 5) {
    printf("between\n");
}

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

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

函数与按值传递

学完你能 学完这课，你能写出自己的函数并调用它，还能解释为什么函数改不了你传进去的那个变量。

函数是一组有名字的指令，你可以反复使用它。你已经用过两个了：main 和 printf。现在你来写自己的函数。

下面是一个函数定义：
int square(int n) { return n * n; }
它有四个部分。返回类型 int，是函数交回的值的类型。单词 void 表示什么也不交回。名字是 square。括号里是形参，也就是函数给收到的值起的名字，每个形参都有类型。花括号里是函数体，放着指令。return 语句交回一个值，并立即结束函数。

调用函数时，写出它的名字，并在括号里放上值：square(5)。你给出的这些值叫实参。调用是一个表达式，它的值就是函数返回的值。所以 square(5) 是 25，你可以打印它，也可以把它存进变量。

编译器从上到下读文件。在你调用一个函数之前，它必须先知道这个函数。通常的办法是写函数原型：把函数的第一行加上分号，放在文件靠前的位置。它的意思是“这个函数存在，类型是这样，函数体稍后给出”。

现在讲关键规则。调用函数时，C 会把每个实参复制到对应的形参里。这叫按值传递。函数处理的是它自己的副本。想象你把一张表格的复印件交给别人。他可以在上面乱涂，而你的原件不会变。所以，如果函数把它的形参设成 0，调用者那边的变量仍然是旧值。想把新值带出来，就用返回值，再赋给变量：side = add_one(side)。

在函数内部创建的变量，包括它的形参，都是局部变量。它们只在函数运行期间存在，别的函数看不到。一个名字能在程序的哪一部分里使用，这个范围叫作用域。两个函数可以各有一个叫 n 的变量，它们是两个不同的盒子。

第 7 课会讲怎样让函数有意地改变调用者的变量。

#include <stdio.h>

int square(int n);
void try_to_reset(int n);
int add_one(int n);

int main(void) {
    int side = 5;
    printf("square(%d) = %d\n", side, square(side));

    try_to_reset(side);
    printf("back in main, side is still %d\n", side);

    side = add_one(side);
    printf("after side = add_one(side), side is %d\n", side);
    return 0;
}

int square(int n) {
    return n * n;
}

void try_to_reset(int n) {
    n = 0;
    printf("inside try_to_reset, n is %d\n", n);
}

int add_one(int n) {
    return n + 1;
}

square(5) = 25
inside try_to_reset, n is 0
back in main, side is still 5
after side = add_one(side), side is 6

int main(void) {
    int n = square(3);
    printf("%d\n", n);
    return 0;
}

int square(int v) { return v * v; }

int square(int v);

int main(void) {
    int n = square(3);
    printf("%d\n", n);
    return 0;
}

int square(int v) { return v * v; }

void double_it(int n) { n = n * 2; }
/* in main: */
double_it(x);

int double_it(int n) { return n * 2; }
/* in main: */
x = double_it(x);

int twice(int n) {
    n * 2;
}

int twice(int n) {
    return n * 2;
}

int helper(void) {
    int inner = 5;
    return 1;
}

int main(void) {
    helper();
    printf("%d\n", inner);
    return 0;
}

int helper(void) {
    int inner = 5;
    return inner;
}

int main(void) {
    int got = helper();
    printf("%d\n", got);
    return 0;
}

数组与 C 字符串：结尾的零

学完你能 学完这课，你能用数组保存一排值，安全地遍历它，并解释为什么 C 字符串需要多一个盒子放结尾的零。

数组是同一类型的一排盒子，在内存里并排放着。int scores[4]; 这一行创建了四个 int 盒子。方括号里的数字是长度。

你通过下标来访问其中一个盒子，下标就是它的位置编号。下标从 0 开始数。scores 的盒子是 scores[0]、scores[1]、scores[2] 和 scores[3]。最后一个有效的下标是长度减 1。没有 scores[4]。但是 C 不会阻止你写它，程序会读写那个位置上碰巧存在的任何内存。这属于未定义行为（第 3 课），会引起很多 bug 和安全漏洞。编译器和浏览器页面通常不会提醒你。第 8 课会介绍一个能提醒你的工具。

你可以用花括号设置初始值：int scores[4] = {70, 85, 90, 65};

数组不会记住自己的长度。表达式 sizeof scores 给出总字节数，四个 int 是 16。再除以 sizeof scores[0]，也就是 4，就得到长度。用这个办法，或者用一个有名字的数，这样长度只写在一个地方。

文字是以 char 数组的形式保存的。C 字符串是一个 char 数组，文字后面跟着一个值为 0 的字节，写作 '\0'。它叫结尾的零，也叫空字符。零标记文字的结束。printf 和 strlen 这样的函数会一直读字符，直到遇到它。

char word[] = "Leon";
编译器让这个数组有五个盒子：L、e、o、n，以及结尾的零。所以 sizeof word 是 5。string.h 里的函数 strlen 数的是零之前的字符个数，所以 strlen(word) 是 4。字符串需要的盒子总是比看得见的长度多一个。如果缺了零，函数会一直读过数组的末尾。

你可以修改其中一个字符：word[0] = 'N'。但是你不能用 = 或 == 去复制或比较整个数组。要比较字符串，用 string.h 里的 strcmp。两个字符串相等时，它返回 0。

要记住 'A' 和 "A" 的区别。'A' 是一个 char。"A" 是有两个盒子的字符串：字母 A 和结尾的零。

#include <stdio.h>
#include <string.h>

int main(void) {
    int scores[4] = {70, 85, 90, 65};
    int length = (int)(sizeof scores / sizeof scores[0]);
    int sum = 0;
    for (int i = 0; i < length; i++) {
        sum += scores[i];
    }
    printf("length = %d, first = %d, last = %d, sum = %d\n", length, scores[0], scores[length - 1], sum);

    char word[] = "Leon";
    printf("sizeof word = %zu, strlen word = %zu\n", sizeof word, strlen(word));
    for (int i = 0; i < 5; i++) {
        printf("word[%d] = %d\n", i, word[i]);
    }

    word[0] = 'N';
    printf("%s\n", word);
    printf("equal to Neon: %d\n", strcmp(word, "Neon") == 0);
    return 0;
}

length = 4, first = 70, last = 65, sum = 310
sizeof word = 5, strlen word = 4
word[0] = 76
word[1] = 101
word[2] = 111
word[3] = 110
word[4] = 0
Neon
equal to Neon: 1

int a[3] = {1, 2, 3};
int sum = 0;
for (int i = 0; i <= 3; i++) {
    sum += a[i];
}

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

char s[4] = "Leon";

char s[5] = "Leon";
/* or let the compiler count: */
char t[] = "Leon";

if (name == "Leon") {
    printf("hello\n");
}

if (strcmp(name, "Leon") == 0) {
    printf("hello\n");
}

char name[] = "Leon";
name = "Mia";

strcpy(name, "Mia");  /* "Mia" and its zero need 4 boxes; name has 5 */

内存是编了号的盒子：地址与指针

学完你能 学完这课，你能把内存画成编了号的盒子，说清楚地址和指针是什么，并用 & 和 * 通过指针读取和修改变量。

先用文字说。把电脑的内存想象成一条很长的街，街上排着许多小盒子。每个盒子放一个字节。每个盒子的门上都漆着一个号码，从街头开始数。这个号码就是盒子的地址。

一个变量住在一个盒子里，或者住在连续的几个盒子里。一个 int 通常需要并排的四个盒子，所以一个 int 占四个地址，它的地址是第一个盒子的号码。三个 int 的数组是连续的十二个盒子。

现在讲新概念。地址只是一个数，所以它也可以存进变量。存放地址的变量叫指针。指针就像一张写着门牌号的卡片。卡片不是房子。但是你可以按号码走到那所房子，往里看，或者改变里面的东西。顺着卡片找过去，这个动作叫解引用。

画一张小图，号码是编的。变量 age 在地址 100，里面放着 20。变量 p 在地址 200，里面放着数字 100。我们说 p 指向 age。下面的例子在注释里画了同样的图。

再用 C 的符号。有两个符号在起作用。
表达式 &x 的意思是“x 的地址”。
表达式 *p 的意思是“p 所指向的那个东西”。

这一行 int *p = &age; 把 p 声明为指向 int 的指针。在声明里，要把星号读作“指向……的指针”。同时它让 p 得到 age 的地址。在表达式里，星号的意思是“顺着指针找过去”。有了这一行之后，*p 和 age 是同一个盒子。读 *p 得到 20。写 *p = 21 就改变了 age。

这解决了第 5 课的问题。函数拿到的是副本，但如果副本是一个地址，函数就可以顺着它找到调用者的变量。调用 add_one(&age) 传入的是 age 的地址。在函数里，*p = *p + 1 改变了调用者的 age。scanf 函数也是这样工作的。在 scanf("%d", &n) 里，& 把 n 的地址交给 scanf，scanf 才能把读到的数存到那里。

指针和数组是近亲。数组的名字代表它第一个盒子的地址。如果 q 指向 nums[0]，那么 q + 1 就指向 nums[1]。给指针加 1，是向前移动一个完整的 int，也就是 4 个字节，而不是一个字节。表达式 *(q + 1) 和 q[1] 的意思相同。

不指向任何东西的指针里放的是 NULL。永远不要顺着 NULL 指针找过去，也不要用从没设置过的指针。程序要么因为段错误而崩溃，要么悄悄破坏数据。

如果你加上 printf("%p\n", (void *)p);，会看到一个真实的地址，例如 0x16d8a3a5c。你的结果会不同，而且每次运行都可能变化。

#include <stdio.h>

/* Memory drawn as numbered boxes (the numbers are made up):

     address   contents      name
     -------   -----------   ----
       100     20            age
       200     100           p      <- p holds the address of age
*/

void add_one(int *p) {
    *p = *p + 1;
}

int main(void) {
    int age = 20;
    int *p = &age;

    printf("age = %d\n", age);
    printf("*p = %d\n", *p);
    printf("p points at age: %d\n", p == &age);

    *p = 21;
    printf("after *p = 21, age = %d\n", age);

    add_one(&age);
    printf("after add_one(&age), age = %d\n", age);

    int nums[3] = {10, 20, 30};
    int *q = nums;
    printf("*q = %d, *(q + 1) = %d, q[2] = %d\n", *q, *(q + 1), q[2]);
    printf("bytes between nums[0] and nums[1]: %d\n", (int)((char *)&nums[1] - (char *)&nums[0]));

    int *nothing = NULL;
    if (nothing == NULL) {
        printf("nothing points at no object\n");
    }
    return 0;
}

age = 20
*p = 20
p points at age: 1
after *p = 21, age = 21
after add_one(&age), age = 22
*q = 10, *(q + 1) = 20, q[2] = 30
bytes between nums[0] and nums[1]: 4
nothing points at no object

int *p;
*p = 5;

int x = 0;
int *p = &x;
*p = 5;

int x = 4;
int *p = &x;
p = 7;

*p = 7;

int *make(void) {
    int local = 5;
    return &local;
}

int make(void) {
    return 5;
}

int *p = NULL;
*p = 5;

if (p != NULL) {
    *p = 5;
}

读懂编译器提示，并使用 -Wall

学完你能 学完这课，你能读懂警告或错误的各个部分，先改第一个错误，并打开编译器的检查，让错误在程序运行之前就暴露出来。

编译器通过提示信息和你对话。如果你读得懂，它们就是你最快的老师。一条提示信息长这样：
hello.c:5:20: warning: format specifies type 'int' but the argument has type 'double' [-Wformat]

从左到右读。hello.c 是文件。5 是行号。20 是列号，也就是这一行里字符的位置。单词 warning 是提示的种类。那句话说的是编译器认为哪里不对。方括号里的名字 -Wformat 是触发提示的那项检查，你可以拿它去搜索。提示下面，编译器通常会显示你写的那一行，并在出问题的地方下面标一个 ^。以 note: 开头的一行，是对上一条提示的补充说明。

提示有三种。错误表示编译器没能生成程序，所以不会产生可执行文件。警告表示程序能生成，但有些地方看起来不对。在你弄明白之前，把每条警告都当作 bug。提示（note）是补充说明。

本篇的提示信息来自 clang，也就是 Mac 上的编译器。Linux 和 WSL 上的 gcc 措辞稍有不同。对上面的例子，它的说法是：format '%d' expects argument of type 'int', but argument 2 has type 'double'。文件、行号、种类、说明和检查名称都有。

默认情况下，编译器对很多有风险的写法是不吭声的。你可以用选项要求更多检查，选项写在 cc 后面。
-Wall 打开常用的警告。尽管名字叫 all，它并没有打开全部警告。
-Wextra 打开更多警告。
-Werror 把每条警告都当作错误，这样你就没法忽略任何一条。
-std=c11 选择 C11 版本的语言。
-g 保留行号信息，工具才能显示你代码的行号。
-fsanitize=address,undefined 生成一个在运行时自我检查的程序。它在遇到第一个错误的内存访问或未定义操作时停下，并指出所在的行。

一条日常好用的命令是：
cc -std=c11 -Wall -Wextra -g -fsanitize=address,undefined main.c -o main

有几个习惯会有帮助。先改第一条提示：一个错误可能引出后面一连串提示，所以每改一处就重新编译一次。记住行号是编译器发现问题的地方，原因可能在上一行。凡是你看不懂的警告，都不要忽略。

sanitizer 很重要，因为本页的“运行”按钮做不到这件事。如果程序读到了数组末尾之外，它在本页照样运行，还会打印出看起来正常的结果，没有任何检查。用 sanitizer 编译，同样的程序会停下，并给出以 ERROR: AddressSanitizer 或 runtime error 开头的报告，指出所在的行。这就是真正的编译器值得你花十分钟安装的原因。

现在你已经能读懂课程前几章里的 C 了：类型与大小、条件与循环、接收副本的函数、带结尾零的数组与字符串，以及指针。课程会把每一项讲得更深，还会加入结构体、文件、用 malloc 分配内存等更多内容。

#include <stdio.h>

int main(void) {
    int scores[3] = {80, 90, 85};
    int sum = 0;
    for (int i = 0; i < 3; i++) {
        sum += scores[i];
    }
    double average = (double)sum / 3;
    printf("sum = %d, average = %.1f\n", sum, average);
    return 0;
}

sum = 255, average = 85.0

#include <stdio.h>
int main(void) {
    itn count = 0;
    count = count + 1;
    printf("%d\n", count);
    return 0;
}

$ cc demo.c -o demo
demo.c:3:5: error: use of undeclared identifier 'itn'
demo.c:4:5: error: use of undeclared identifier 'count'
demo.c:4:13: error: use of undeclared identifier 'count'
demo.c:5:20: error: use of undeclared identifier 'count'
4 errors generated.

int count = 0;

#include <stdio.h>
int main(void) {
    int total = 3
    printf("%d\n", total);
    return 0;
}

int total = 3;

#include <stdio.h>
int main(void) {
    int total;
    total = total + 5;
    printf("%d\n", total);
    return 0;
}

$ cc demo.c -o demo
(no output: it builds)

$ cc -std=c11 -Wall -Wextra demo.c -o demo
demo.c:4:13: warning: variable 'total' is uninitialized when used here [-Wuninitialized]

#include <stdio.h>
int main(void) {
    int a[3] = {1, 2, 3};
    int sum = 0;
    for (int i = 0; i <= 3; i++) {
        sum += a[i];
    }
    printf("%d\n", sum);
    return 0;
}

(Run button on this page, or a plain cc build: prints a normal-looking sum)

$ cc -std=c11 -Wall -Wextra -g -fsanitize=address,undefined demo.c -o demo
$ ./demo
demo.c:6:16: runtime error: index 3 out of bounds for type 'int[3]'