C语言系列：3、流程控制

C语言系列：3、流程控制

---

1. 语句与程序块

在 x = 0、i++或printf(…)这样的表达式之后加上一个分号（;），它们就变成了
语句。例如：

x = 0;
i++;
printf(...);

在C语言中，分号是语句结束符，而Pascal 等语言却把分号用作语句之间的分隔符。

用一对花括号“{”与“}”把一组声明和语句括在一起就构成了一个复合语句（也叫作
程序块），复合语句在语法上等价于单条语句。函数体中被花括号括起来的语句便是明显一例。

if、else，while与for之后被花括号括住的多条语句也是类似的例子。右花括号用于结束程序块，其后不需要分号。

2. if-else语句

if-else语句用于条件判定，其语法如下所示：

if {表达式}
	语句1
else
	语句2

其中else部分是可选的。该语句执行时，先计算表达式的值，如果其值为真（即表达式的值为非0），则执行语句1；如果其值为假（即表达式的值为0），并且该语句包含else 部分，则执行语句2。

由于if语句只是简单测试表达式的数值，因此可以对某些代码的编写进行简化。最明显的例子是用如下写法

if (表达式)

来代替

if (表达式!0)

某些情况下这种形式是自然清晰的，但也有些情况下可能会含义不清。

因为if-else 语句的else 部分是可选的，所以在嵌套的if 语句中省略它的else 部分将导致歧义。解决的方法是将每个else与最近的前一个没有else配对的if进行匹配。

例如，在下列语句中：

if (n > 0)
	if (a > b)
		z = a;
	else
		z = b;

else 部分与内层的if 匹配，我们通过程序的缩进结构也可以看出来。如果这不符合我们的意图，则必须使用花括号强制实现正确的匹配关系：

if (n > 0) {
	if (a > b)
		z = a;
}
else
	z = b;

歧义性在下面这种情况下尤为有害：

if (n > 0)
	for (i = 0; i < n; i++)
		if (s[i] > 0) {
			printf("...");
			return i;
		}
else /* WRONG */
	printf("error -- n is negative\n");

程序的缩进结构明确地表明了设计意图，但编译器无法获得这一信息，它会将else部分与内层的if配对。这种错误很难发现，因此我们建议在有if语句嵌套的情况下使用花括号。

顺便提醒读者注意，在语句

if (a > b)
	z = a;
else
	z = b;

中，z = a 后有一个分号。这是因为，从语法上讲，跟在if后面的应该是一条语句，而像“z=a;”这类的表达式语句总是以分号结束的。

3. else-if语句

在 C语言中我们会经常用到下列结构：

if (表达式)
	语句
else if (表达式)
	语句
else if (表达式)
	语句
else if (表达式)
	语句
else
	语句

因此我们在这里单独说明一下。这种if语句序列是编写多路判定最常用的方法。其中的各表达式将被依次求值，一旦某个表达式结果为真，则执行与之相关的语句，并终止整个语句序列的执行。同样，其中各语句既可以是单条语句，也可以是用花括号括住的复合语句。

最后一个else部分用于处理“上述条件均不成立”的情况或默认情况，也就是当上面各条件都不满足时的情形。有时候并不需要针对默认情况执行显式的操作，这种情况下，可以把该结构末尾的

else
	语句

部分省略掉；该部分也可以用来检查错误，以捕获“不可能”的条件。

这里通过一个折半查找函数说明三路判定程序的用法。该函数用于判定已排序的数组v中是否存在某个特定的值x。数组v的元素必须以升序排列。如果v中包含x，则该函数返回x在v中的位置（介于0～n-1 之间的一个整数）；否则，该函数回-1。

在折半查找时，首先将输入值x 与数组v 的中间元素进行比较。如果x 小于中间元素的值，则在该数组的前半部分查找；否则，在该数组的后半部分查找。在这两种情况下，下一步都是将x 与所选部分的中间元素进行比较。这个过程一直进行下去，直到找到指定的值或查找范围为空。

/* binsearch: find x in v[0] <= v[1] <= ... <= v[n-1] */
int binsearch(int x, int v[], int n)
{
	int low, high, mid;
	
    low = 0;
	high = n - 1;
	while (low <= high) {
		mid = (low+high)/2;
		if (x < v[mid])
			high = mid + 1;
		else if (x > v[mid])
			low = mid + 1;
		else /* found match */
			return mid;
	}

    return -1; /* no match */
}

该函数的基本判定是：在每一步判断x 小于、大于还是等于中间元素v[mid]。使用
else-if结构执行这种判定很自然。

4. switch语句

switch语句是一种多路判定语句，它测试表达式是否与一些常量整数值中的某一个值匹配，并执行相应的分支动作（常量整数值让switch显的比较鸡肋，Go中对这块进行了优化）。

switch (表达式) {
case 常量表达式: 语句序列
case 常量表达式: 语句序列
default: 语句序列
}

每一个分支都由一个或多个整数值常量或常量表达式标记。如果某个分支与表达式的值匹配，则从该分支开始执行。各分支表达式必须互不相同。如果没有哪一分支能匹配表达式，则执行标记为default的分支。default分支是可选的。如果没有default分支也没有其它分支与表达式的值匹配，则该switch语句不执行任何动作。各分支及default分支的排列次序是任意的。

我们曾用if…else if…else 结构编写过一个程序以统计各个数字、空白符及其它所有字符出现的次数。下面我们用switch语句改写该程序如下：

#include <stdio.h>
main() /* count digits, white space, others */
{
	int c, i, nwhite, nother, ndigit[10];

    nwhite = nother = 0;
	for (i = 0; i < 10; i++)
		ndigit[i] = 0;
	while ((c = getchar()) != EOF) {
		switch (c) {
		case '0': case '1': case '2': case '3': case '4':
		case '5': case '6': case '7': case '8': case '9':
			ndigit[c-'0']++;
			break;
		case ' ':
		case '\n':
		case '\t':
			nwhite++;
			break;
		default:
			nother++;
			break;
		}
	}
	printf("digits =");
	for (i = 0; i < 10; i++)
		printf(" %d", ndigit[i]);
	printf(", white space = %d, other = %d\n", nwhite, nother);
	return 0;
}

break 语句将导致程序的执行立即从switch 语句中退出。在switch 语句中，case
的作用只是一个标号，因此，某个分支中的代码执行完后，程序将进入下一分支继续执行，除非在程序中显式地跳转。跳出switch语句最常用的方法是使用break语句与return语句。break 语句还可强制控制从while、for 与do 循环语句中立即退出，对于这一点，我们稍后还将做进一步介绍。

依次执行各分支的做法有优点也有缺点。好的一面是它可以把若干个分支组合在一起完成一个任务，如上例中对数字的处理。但是，正常情况下为了防止直接进入下一个分支执行，每个分支后必须以一个break语句结束。从一个分支直接进入下一个分支执行的做法并不健全，这样做在程序修改时很容易出错。除了一个计算需要多个标号的情况外，应尽量减少从一个分支直接进入下一个分支执行这种用法，在不得不使用的情况下应该加上适当的程序注释。

作为一种良好的程序设计风格，在switch语句最后一个分支（即default分支）的后
面也加上一个break语句。这样做在逻辑上没有必要，但当我们需要向该switch语句后添加其它分支时，这种防范措施会降低犯错误的可能性。

5. while循环与for循环

在while循环语句

while (表达式)
	语句

中，首先求表达式的值。如果其值非0，则执行语句，并再次求该表达式的值。这一循环过程一直进行下去，直到该表达式的值为0为止，随后继续执行语句后面的部分。
for 循环语句:

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

它等价于下列while语句：

表达式 1;
while (表达式2) {
	语句
	表达式3;
}

但当while 或for 循环语句中包含continue 语句时，上述二者之间就不一定等价了。

从语法角度看，for 循环语句的3 个组成部分都是表达式。最常见的情况是，表达式1与表达式3 是赋值表达式或函数调用，表达式2 是关系表达式。这3 个组成部分中的任何部分都可以省略，但分号必须保留。如果在for 语句中省略表达式1 与表达式3，它就退化成了while 循环语句。如果省略测试条件，即表达式2，则认为其值永远是真值，因此，下列for循环语句：

for (;;) {
	...
}

是一个“无限”循环语句，这种语句需要借助其它手段（如break语句或return语句）才能终止执行。

在设计程序时到底选用while循环语句还是for循环语句，主要取决于程序设计人员的个人偏好。例如，在下列语句中：

while ((c = getchar()) == ' ' || c == '\n' || c = '\t')
; /* skip white space characters */

因为其中没有初始化或重新初始化的操作，所以使用whi1e循环语句更自然一些。

如果语句中需要执行简单的初始化和变量递增，使用for 语句更合适一些，它将循环控制语句集中放在循环的开头，结构更紧凑、更清晰。通过下列语句可以很明显地看出这一点：

for (i = 0; i < n; i++)
	...

这是C 语言处理数组前n 个元素的一种习惯性用法，它类似于Fortran 语言中的DO 循环或Pascal 语言中的for 循环。但是，这种类比并不完全准确，因为在C 语言中，for 循环语句的循环变量和上限在循环体内可以修改，并且当循环因某种原因终止后循环变量i 的值仍然保留。因为for语句的各组成部分可以是任何表达式，所以for语句并不限于通过算术级数进行循环控制。尽管如此，牵强地把一些无关的计算放到for 语句的初始化和变量递增部分是一种不好的程序设计风格，该部分放置循环控制运算更合适。

作为一个较大的例子，我们来重新编写将字符串转换为对应数值的函数atoi。

下面是程序的结构，从中可以看出输入的格式：

如果有空白符的话，则跳过
如果有符号的话，则读取符号
取整数部分，并执行转换

其中的每一步都对输入数据进行相应的处理，并为下一步的执行做好准备。当遇到第一个不能转换为数字的字符时，整个处理过程终止。

#include <ctype.h>
/* atoi: convert s to integer; version 2 */
int atoi(char s[])
{
	int i, n, sign;
	for (i = 0; isspace(s[i]); i++) /* skip white space */
		;
	sign = (s[i] == '-') ? -1 : 1;
	if (s[i] == '+' || s[i] == '-') /* skip sign */
		i++;
	for (n = 0; isdigit(s[i]); i++)
		n = 10 * n + (s[i] - '0');
	
    return sign * n;
}

标准库中提供了一个更完善的函数strtol，它将字符串转换为长整型数。有关函数strtol的详细信息，请参见附录B.5节。

把循环控制部分集中在一起，对于多重嵌套循环，优势更为明显。下面的函数是对整型数组进行排序的Shell排序算法。Shell排序算法是D. L. Shell于1959 年发明的，其基本思想是：先比较距离远的元素，而不是像简单交换排序算法那样先比较相邻的元素。这样可以快速减少大量的无序情况，从而减轻后续的工作。被比较的元素之间的距离逐步减少，直到减少为1，这时排序变成了相邻元素的互换。

/* shellsort: sort v[0]...v[n-1] into increasing order */
void shellsort(int v[], int n)
{
	int gap, i, j, temp;
	for (gap = n/2; gap > 0; gap /= 2)
		for (i = gap; i < n; i++)
			for (j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap) {
				temp = v[j];
				v[j] = v[j+gap];
				v[j+gap] = temp;
			}
}

该函数中包含一个三重嵌套的for循环语句。最外层的for语句控制两个被比较元素之间的距离，从n/2 开始，逐步进行对折，直到距离为0。中间层的for 循环语句用于在元素间移动位置。最内层的for语句用于比较各对相距gap个位置的元素，当这两个元素逆序时把它们互换过来。由于gap的值最终要递减到1，因此所有元素最终都会位于正确的排序位置上。注意，即使最外层for 循环的控制变量不是算术级数，for 语句的书写形式仍然没有变，这就说明for语句具有很强的通用性。

逗号运算符“,”也是C 语言优先级最低的运算符，在for 语句中经常会用到它。被逗
号分隔的一对表达式将按照从左到右的顺序进行求值，表达式右边的操作数的类型和值即为其结果的类型和值。这样，在for 循环语句中，可以将多个表达式放在各个语句成分中，比如同时处理两个循环控制变晕。我们可以通过下面的函数reverse(s)来举例。该函数用于倒置字符串s中各个字符的位置。

#include <string.h>
/* reverse: reverse string s in place */
void reverse(char s[])
{
	int c, i, j;
	for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
		c = s[i];
		s[i] = s[j];
		s[j] = c;
	}
}

某些情况下的逗号并不是逗号运算符，比如分隔函数参数的逗号，分隔声明中变量的逗号等，这些逗号并不保证各表达式按从左至右的顺序求值。

应该慎用逗号运算符。逗号运算符最适用于关系紧密的结构中，比如上面的reverse函数内的for 语句，对于需要在单个表达式中进行多步计算的宏来说也很适合。逗号表达式还适用于reverse函数中元素的交换，这样，元素的交换过程便可以看成是一个单步操作。

for (i = 0, j = strlen(s)-1; i < j; i++, j--)
	c = s[i], s[i] = s[j], s[j] = c;

6. do-while循环

while与for这两种循环在循环体执行前对终止条件进行测试。与此相反，C语言中的第三种循环——do-while循环则在循环体执行后测试终止条件，这样循环体至少被执行一次。
do-while循环的语法形式如下：

do
	语句
while (表达式);

在这一结构中，先执行循环体中的语句部分，然后再求表达式的值。如果表达式的值为真，则再次执行语句，依此类推。当表达式的值变为假，则循环终止。除了条件测试的语义不同外，do-while循环与Pascal语言的repeat-until语句等价。

经验表明，do-while循环比while循环和for循环用得少得多。尽管如此，do-while
循环语句有时还是很有用的，下面我们通过函数itoa来说明这一点。itoa函数是atoi函数的逆函数，它把数字转换为字符串。这个工作比最初想像的要复杂一些。如果按照atoi函数中生成数字的方法将数字转换为字符串，则生成的字符串的次序正好是颠倒的，因此，我们首先要生成反序的字符串，然后再把该字符串倒置。

/* itoa: convert n to characters in s */
void itoa(int n, char s[])
{
	int i, sign;
	if ((sign = n) < 0) /* record sign */
		n = -n; /* make n positive */
	i = 0;
	do { /* generate digits in reverse order */
		s[i++] = n % 10 + '0'; /* get next digit */
	} while ((n /= 10) > 0); /* delete it */
	if (sign < 0)
		s[i++] = '-';
	s[i] = '\0';
	reverse(s);
}

这里有必要使用do-while语句，至少使用do-while语句会方便一些，因为即使n的
值为0，也至少要把一个字符放到数组s 中。其中的do-while 语句体中只有一条语句，尽管没有必要，但我们仍然用花括号将该语句括起来了，这样做可以避免草率的读者将while部分误认为是另个while循环的开始。

7. break语句与continue语句

不通过循环头部或尾部的条件测试而跳出循环，有时是很方便的。break 语句可用于从for、while与do-while等循环中提前退出，就如同从switch语句中提前退出一样。break语句能使程序从switch语句或最内层循环中立即跳出。

下面的函数trim用于删除字符串尾部的空格符、制表符与换行符。当发现最右边的字符为非空格符、非制表符、非换行符时，就使用break语句从循环中退出。

/* trim: remove trailing blanks, tabs, newlines */
int trim(char s[])
{
	int n;
	for (n = strlen(s)-1; n >= 0; n--)
		if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
			break;
	s[n+1] = '\0';
	return n;
}

strlen函数返回字符串的长度。for循环从字符串的末尾开始反方向扫描寻找第一个不是空格符、制表符以及换行符的字符。当找到符合条件的第一个字符，或当循环控制变量n变为负数时（即整个字符串都被扫描完时），循环终止执行。读者可以验证，即使字符串为空或仅包含空白符，该函数也是正确的。

continue 语句与break 语句是相关联的，但它没有break 语句常用。continue 语
句用于使for、while 或do-while 语句开始下一次循环的执行。在while 与do-while
语句中，continue 语句的执行意味着立即执行测试部分；在for 循环中，则意味着使控制转移到递增循环变量部分。continue 语句只用于循环语句，不用于switch 语句。某个循环包含的switch语句中的continue语句，将导致进入下一次循环。

例如，下面这段程序用于处理数组a 中的非负元素。如果某个元素的值为负，则跳过不处理。

for (i = 0; i < n; i++)
	if (a[i] < 0) /* skip negative elements */
		continue;
	... /* do positive elements */

当循环的后面部分比较复杂时，常常会用到continue 语句。这种情况下，如果不使用continue 语句，则可能需要把测试颠倒过来或者缩进另一层循环，这样做会使程序的嵌套更深。

8. goto语句与标号

C语言提供了可随意滥用的goto语句以及标记跳转位置的标号。从理论上讲，goto语句是没有必要的，实践中不使用goto语句也可以很容易地写出代码。

但是，在某些场合下goto语句还是用得着的。最常见的用法是终止程序在某些深度嵌套的结构中的处理过程，例如一次跳出两层或多层循环。这种情况下使用break语句是不能达到目的的，它只能从最内层循环退出到上一级的循环（其它一些语言使用命名空间的方式处理这种情况）。下面是使用goto语句的一个例子：

for ( ... )
	for ( ... ) {
		...
		if (disaster)
			goto error;
	}
	...
error:
/* clean up the mess */

在该例子中，如果错误处理代码很重要，并且错误可能出现在多个地方，使用goto语句将会比较方便。

标号的命名同变量命名的形式相同，标号的后面要紧跟一个冒号。标号可以位于对应的goto语句所在函数的任何语句的前面。标号的作用域是整个函数。

我们来看另外一个例子。考虑判定两个数组a 与b 中是否具有相同元素的问题。一种可能的解决方法是：

for (i = 0; i < n; i++)
	for (j = 0; j < m; j++)
		if (a[i] == b[j])
			goto found;
/* didn't find any common element */
...
found:
/* got one: a[i] == b[j] */
...

所有使用了goto语句的程序代码都能改写成不带goto语句的程序，但可能会增加一些额外的重复测试或变量。例如，可将上面判定是否具有相同数组元素的程序段改写成下列形式：

found = 0;
for (i = 0; i < n && !found; i++)
	for (j = 0; j < m && !found; j++)
		if (a[i] == b[j])
			found = 1;
if (found)
	/* got one: a[i-1] == b[j-1] */
	...
else
	/* didn't find any common element */
	...

大多数情况下，使用goto语句的程序段比不使用goto语句的程序段要难以理解和维护，少数情况除外，比如我们前面所举的几个例子。尽管该问题并不太严重，但我们还是建议尽可能少地使用goto语句。