C 的控制语句只有九种,它们组合出三种结构:顺序、选择、循环。选择用 if 和 switch,循环用 while、for、do while。这些语句的语法都不复杂,出问题的地方几乎都在“条件表达式到底算出了什么”和“跳转之后从哪继续”。

if 只控制它后面的那一条语句

if (表达式)
    语句

表达式为真就执行语句,为假就跳过。C 的条件表达式不看类型,只看值:0 为假,任何非 0 的值都为真。

#include <stdio.h>
 
int main(void)
{
    int num = 0;
 
    scanf("%d", &num);
    if (num % 2 != 0)
        printf("%d 是奇数\n", num);
    else
        printf("%d 是偶数\n", num);
    return 0;
}

课件这里写的是 num % 2 == 1,输入正整数没问题,输入负数就会错。C99 规定 % 的余数符号跟着被除数走,-3 % 2 得 -1,不等于 1,于是 -3 会被判成偶数。判奇数的条件是 num % 2 != 0,它对正负都成立。

if 和 else 默认都只带一条语句。想让它们管住多条,就得用花括号包成复合语句:

if (age >= 18)
{
    printf("成年了\n");
    printf("可以谈恋爱了\n");
}

漏掉花括号时,第二条语句和 if 没有关系,条件真假都会执行。

else 后面可以再接一个 if,形成 else if 链。判断年龄区间时,前面的条件已经把下界排除掉了,后面只需要写上界:

if (age < 18)
    printf("少年\n");
else if (age <= 44)
    printf("青年\n");
else if (age <= 59)
    printf("中老年\n");
else if (age <= 89)
    printf("老年\n");
else
    printf("老寿星\n");

把 age <= 89 挪到最前面,20 岁的人也会打印“老年”。宽泛的条件必须往后放。

嵌套 if 也能写成多层判断,例如先判正负,再在正数里判奇偶:

if (num > 0)
{
    if (num % 2 == 0)
        printf("偶数\n");
    else
        printf("奇数\n");
}
else
{
    printf("非正数\n");
}

else 认最近的 if,缩进不算数

int a = 0;
int b = 2;
 
if (a == 1)
    if (b == 2)
        printf("hehe\n");
else
    printf("haha\n");

按缩进看,else 像是配对外层 if;按语法,它属于内层那个还没配对的 if (b == 2)。内层的 if-else 整个嵌在外层条件里,外层 a == 1 不成立,里面一句都执行不到,程序什么都不输出。

左边是代码,else 和内层 if 对齐;右边控制台除了“按任意键关闭此窗口”没有任何输出,说明 else 没有跟外层 if 配对

规则是 else 与最近的、尚未配对的 if 结合。想让它配外层,就给内层加花括号;只有一条语句也加括号,配对关系一眼可见。

关系表达式给出 0 或 1

关系运算符有六个:>、<、>=、<=、==、!=。它们比较两个值,结果是 0 或 1。

== 和 = 是两个不同的运算符。if (x = 3) 合法,因为赋值表达式本身有值,值是 3,条件恒真;本意通常是 x == 3。把常量写在左边,if (3 == x),手滑写成 3 = x 时编译器会报“左操作数不是可修改的左值”,在编译期就能拦住。

关系运算符不宜连用:

int age = 10;
 
if (18 <= age <= 36)      /* 实际是 (18 <= age) <= 36 */
    printf("青年\n");

18 <= 10 得 0,再拿 0 和 36 比,0 <= 36 为真,于是 10 岁也打印“青年”。语法完全合法,逻辑完全错。区间判断要写成 age >= 18 && age <= 36。

关系运算符从左到右结合,所以 a < b == c < d 读作 (a < b) == (c < d)。优先级记不住就加括号,把想要的结合顺序写明;多写括号不会改变运算本身,只会让读代码的人少猜一次。

条件运算符是表达式,有值

exp1 ? exp2 : exp3 是唯一需要三个操作数的运算符。exp1 为真时算 exp2,否则算 exp3,整个表达式的值就是被选中那个分支的值。

int a = 0;
int b = 0;
 
scanf("%d", &a);
b = a > 5 ? 3 : -3;
printf("%d\n", b);

它和 if 的区别在于“有值”,能直接参与赋值和运算。找两个数的较大值可以写成:

int m = a > b ? a : b;

两个分支的类型会被统一。1 ? 3 : 3.14 的结果类型是 double,因为 int 和 double 要合成一个公共类型。

&&、||、! 判断的是真假

  • ! 逻辑取反,真变假、假变真;
  • && 逻辑与,两边都为真才为真;
  • || 逻辑或,只要有一边为真就为真。

&& 的真值表:

a 和 b 都为非 0 时 a&&b 才为 1,其余三行都是 0;表里的“非 0”不是某个固定值,任何非零数都算真

季节判断用 && 把两个条件合起来:

if (month >= 3 && month <= 5)
    printf("春季\n");

冬天用 ||:

if (month == 12 || month == 1 || month == 2)
    printf("冬季\n");

写成 month == 12 || 1 || 2 是另一回事。|| 只问操作数是不是非 0,1 本身就是非 0,整个表达式立刻为真,输入 7 月也会打印“冬季”。每个比较都要写完整。

闰年的规则是“能被 4 整除且不能被 100 整除,或者能被 400 整除”:

if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    printf("是闰年\n");

短路是标准规定的语义

&& 和 || 都先算左边,再决定要不要算右边。左边已经能定下整个结果时,右边不求值,这叫短路求值(short-circuit evaluation)。

int a = 0, b = 2, c = 3, d = 4;
int i = a++ && ++b && d++;
 
printf("a=%d b=%d c=%d d=%d i=%d\n", a, b, c, d, i);   /* a=1 b=2 c=3 d=4 i=0 */

a++ 的值是 0,&& 立刻判定整个表达式为假,后面的 ++b、d++ 一次都没执行,所以 b 仍是 2。换成 ||,左边为 0 时会继续往右算,++b 就会执行。条件里只放判断,要自增就单独写一行。

短路还有一个正当用途,是先检查再访问:

if (p != NULL && p->value > 0)

p 为空时右边不会被碰。

&& 和按位与 & 不是一回事。2 && 4 是 1,因为两个都非 0;2 & 4 是 0,因为二进制逐位与的结果为 0。按位与没有短路,也不保证结果只有 0 和 1。

switch 的 case 是标签,不是独立分支

switch (表达式)
{
case 常量1:
    语句
case 常量2:
    语句
default:
    语句
}

switch 后面的表达式必须是整型表达式,case 后面的值必须是整型常量表达式。变量、浮点数、字符串都不能做 case 的值。

课件用“除以 3 的余数”对比 if 和 switch:

switch (n % 3)
{
case 0:
    printf("整除,余数为 0\n");
    break;
case 1:
    printf("余数是 1\n");
    break;
case 2:
    printf("余数是 2\n");
    break;
default:
    printf("余数是负数\n");
    break;
}

case 只是跳转标签。程序算出 n % 3,直接跳到匹配的标签,然后一条条往下执行,直到遇到 break 或 switch 结束。去掉 break 后,输入 7 会先打印“余数是 1”,再穿透到下一行打印“余数是 2”。switch 的表达式只求值一次,这也是它和 if else 链的一个区别:链式判断每次比较都要重新算一遍。

有意穿透是合法写法,多个标签叠在一起共享一段代码:

switch (day)
{
case 1:
case 2:
case 3:
case 4:
case 5:
    printf("工作日\n");
    break;
case 6:
case 7:
    printf("休息日\n");
    break;
default:
    printf("输入错误\n");
    break;
}

default 在所有 case 都不匹配时执行。它和 case 没有顺序要求,放在中间也合法,习惯上放在末尾。

课件这个余数例子有一个漏洞:题目说“输入任意一个整数值”,但负数取余得到 -1 或 -2,三个 case 一个都匹配不上,程序什么都不输出。要么在题面里限定非负,要么保留 default。课件后面打印星期的那段代码里,case 1: 用的是中文全角冒号,源码里它只是几个普通字节,编译器会报非法字符。抄代码时先扫一遍标点。

三种循环,三种摆放方式

while 和 if 的语法几乎一样,区别是条件成立时 while 会回到条件处再判一次:

while 的三个要素分散在三处:循环外初始化 i,圆括号里判断 i <= 10,循环体末尾调整 i;漏掉任何一处都可能变成死循环

int i = 1;
 
while (i <= 10)
{
    printf("%d ", i);
    i = i + 1;
}

while (1) printf("hehe\n"); 会一直打印,因为条件永远为非 0。写循环时先想清楚三个值:首次进入时、末次进入时、刚好不进入时。

逆序打印整数的每一位,用取余和整除:

#include <stdio.h>
 
int main(void)
{
    int n = 0;
 
    scanf("%d", &n);
    while (n)
    {
        printf("%d ", n % 10);
        n /= 10;
    }
    return 0;
}

n % 10 拿到最低位,n /= 10 把最低位去掉,循环到 n 变成 0 为止。输入 1234 输出 4 3 2 1。

for 把三个要素集中到一行:

for (表达式1; 表达式2; 表达式3)
    语句

表达式 1 初始化,只在循环开始时执行一次;表达式 2 是判断,非 0 就进入循环体;表达式 3 在每轮循环体之后执行,用来调整变量。

for 的三个部分都在圆括号里:i = 1 初始化,i <= 10 判断,i++ 调整;执行顺序是初始化一次,然后判断、循环体、调整,再判断

int i = 0;
 
for (i = 1; i <= 10; i++)
{
    printf("%d ", i);
}

这段的执行顺序是:i = 1 只做一次;判 1 <= 10 成立,打印 1;i++ 让 i 变 2;再判、再打印、再调整。i 到 10 打印完,i++ 变成 11,判断失败,循环结束。初始化只在开头执行一次,判断执行 n+1 次(末次为假),调整执行 n 次。

while 和 for 都有初始化、判断、调整三件事。for 把三件事放在一行,代码变长时不容易漏掉调整语句,这也是它更常用的原因。

求和练习能看出循环写法的差别:

int i = 0, sum = 0;
 
for (i = 1; i <= 100; i++)
{
    if (i % 3 == 0)
        sum += i;
}
 
sum = 0;
for (i = 3; i <= 100; i += 3)   /* 直接产生 3 的倍数,省掉判断 */
{
    sum += i;
}
printf("%d\n", sum);            /* 1683 */

do while 先执行一次循环体,再判断:

do
    语句
while (表达式);

while 和 for 都是先判断后执行,条件一开始就为假时一次都不进;do while 至少执行一次。数位数适合用它,因为 0 也是一位数:

int n = 0, cnt = 0;
 
scanf("%d", &n);
do
{
    cnt++;
    n /= 10;
} while (n);
 
printf("%d\n", cnt);

break 跳出循环,continue 跳回判断

break 立刻结束最近的一层循环。continue 跳过本轮剩下的循环体,回到“下一次判断”的位置。这个“位置”在 while 和 for 里不一样。

while 的调整语句写在循环体末尾,也就在 continue 后面:

int i = 1;
 
while (i <= 10)
{
    if (i == 5)
        continue;      /* 跳回 i <= 10,i 仍是 5 */
    printf("%d ", i);
    i = i + 1;         /* 永远轮不到 */
}

i 到 5 之后,continue 每次都跳过 i = i + 1,条件永远成立,屏幕停在 1 2 3 4,程序不再前进。

for 的调整语句在圆括号里,continue 够不着它:

并排对比:左边 while 的 i = i + 1 在 continue 之后,执行不到;右边 for 的 i++ 属于循环控制,continue 之后照样执行,箭头指向 i++

for (i = 1; i <= 10; i++)
{
    if (i == 5)
        continue;      /* 跳到 i++,i 变成 6 */
    printf("%d ", i);  /* 1 2 3 4 6 7 8 9 10 */
}

do while 的 continue 同样跳到条件判断。课件说它“和 while 几乎一样”,课件给的那段参考代码把 i = i + 1 写在 continue 后面,i 到 5 时会停在那里出不来。要在 do while 里用 continue,先把调整语句挪到它前面,或者换 for。

break 只跳出最近的一层。三层嵌套里在最内层 break,外面两层继续转。

循环套循环,跳不出去就交给 goto

判断 100 到 200 之间的素数,需要一层循环产生被判断的数,另一层循环产生试除数:

#include <stdio.h>
 
int main(void)
{
    int i = 0;
 
    for (i = 100; i <= 200; i++)
    {
        int j = 0;
        int flag = 1;   /* 先假设 i 是素数 */
 
        for (j = 2; j < i; j++)
        {
            if (i % j == 0)
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            printf("%d ", i);
    }
    return 0;
}

内层 break 只结束试除循环,外层继续取下一个 i。这是 break 只跳一层的正常用法。

goto 可以在同一个函数内跳到指定标号:

#include <stdio.h>
 
int main(void)
{
    printf("hehe\n");
    goto next;
    printf("haha\n");
 
next:
    printf("跳过了 haha 的打印\n");
    return 0;
}

它能把执行流程搅乱,日常代码里能不用就不用。但在多层循环里要一次跳出,goto 比逐层写 break 或标志变量干净:

#include <stdio.h>
 
int main(void)
{
    int i = 0, j = 0, k = 0;
 
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            for (k = 0; k < 3; k++)
            {
                if (i == 1 && j == 1 && k == 1)
                    goto done;
            }
        }
    }
 
done:
    printf("跳出的位置是 i=%d j=%d k=%d\n", i, j, k);
    return 0;
}

三层循环写三个 break 只能一层层退,goto done 一步就到后面的清理或收尾代码。标号只在同一个函数内可见,不能跨函数跳。