<<c程序设计语言>>第三章 程序控制流

3.1 语句与程序块

在表达式之后加上一个分号（；），它们就变成了语句。

用一对花括号“{”与“}”把一组声明和语句括在一起就构成了程序块，在语法上等价于单条语句。

3.2 if-else语句

每个else与最近的前一个没有else配对的if进行匹配。

if (n > 0)

     if (a > b)

          z = a;

else

     z = b;

程序的缩进结构明确表明了设计意图，但编译器无法获得这一信息，它会将else部分与内层的if配对。

所以最好经常把if else语句块括起来！

 

二分查找：

/*  binsearch：在v[0]<=v[1]<=v[2]<=……<=v[n-1]中查找x  */
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       /*  找到了匹配的值 */
return  mid;
}
return  -1;    /* 没有查到*/
}

 

练习3-1     上面折半查找的例子中，while循环语句内执行了两次测试。重写该函数，

使循环内部只执行一次测试。比较两种版本函数的运行时间。

答：

while (low <= high) {

     mid = (low + high) / 2;

     if (x < v[mid])

          high = mid - 1;

     else

          low = mid ;

}

if (x == v[mid])

     return mid;

else

     return -1;

 

3.4   switch语句
s w i t c h语句是一种多路判定语句，它根据表达式是否与若干常量整数值中的某一个匹配来相
应地执行有关的分支动作。
switch  ( 表达式)  {
case  常量表达式:  语句序列
case  常量表达式:  语句序列
default:  语句序列

}

 

如果没有default情形，且没有任何一个情景匹配，那么该switch语句不执行任何动作。各个case的执行顺序是任意的。

 

在s w i t c h语句中c a s e情形的作用就像标号一样，在某个c a s e情形之后的代码执行完后，就进入下一个c a s e情形执行，除非显式控制转出。转出
s w i t c h语句最常用的方法是使用b r e a k语句与r e t u r n语句。为了防止直接进入下一个情形，最好在每个情形后以break结尾。

 

练习3-2     编写一个函数escape(s, t)，将字符串t复制到字符串s中，并在复制过程中将换行符、

制表符等不可见字符分别转换为\n、\t等相应可见的转义字符。再编写一个相反功能的函数。

答：

#include <stdio.h>

void escape(char s[], char t[])
{
     int i, j;
     for (i = 0, j = 0; s[i] != '\0'; i++) {
          switch (s[i]) {
          case '\n':
               t[j++] = '\\';
               t[j++] = 'n';
               break;
          case '\t':
               t[j++] = '\\';
               t[j++] = 't';
               break;
          default:
               t[j++] = s[i];
               break;
          }
     }
     t[j] = '\0';
}
void escape2(char s[], char t[])
{
     int i, j;
     for (i = 0, j = 0; s[i] != '\0'; j++) {
          switch (s[i]) {
          case '\\':
               if (s[i+1] == 'n') {
                    t[j] = '\n';
                    i += 2;
               }
               else if (s[i+1] == 't') {
                    t[j] = '\t';
                    i += 2;
               }
               else {
                    t[j] = s[i];
                    i++;
               }
          default:
               t[j] = s[i++];
               break;
          }
     }
}

练习3-3     编写函数expand(s1, s2)，将字符串s1中类似于a-z一类的速记符号在字符串s2中

扩展为等价的完整列表abc...xyz。该函数可以处理大小写字母和数字，并可以处理a-b-c、

a-z0-9与-a-z等类似的情况。作为前导和尾随的-字符原样排印。

答：

#include <stdio.h>
void expand(char s1[], char s2[])
{
     int i, j, k;
     i = j = 0;
     while (s1[i] != '\0') {
          if (s1[i] == '-' && 0 < i && s1[i+1] != '\0' &&
               s1[i-1] != '-' && s1[i+1] != '-') {
               j--;     // avoid duplicate letter
               for (k = s1[i-1]; k <= s1[i+1]; k++, j++)
                    s2[j] = k;
               i += 2;
          } else {
               s2[j++] = s1[i++];
          }
     }
     s2[j] = '\0';
}
main()
{
     char s1[] = "-a-b-hAbC-G0-8---";
     char s2[100];
     expand(s1, s2);
     printf("before expand:%s\nafter expand: %s\n", s1, s2);
}

 

3.5 while循环与for循环

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

     语句

等价于=>

表达式1;

while (表达式2) {

     语句

     表达式3;

}

如果表达式1与表达式3 被省略了，那么它退化成了w h i l e循环语句。

如果用于测试的表达式2 不存在，那么就认为表达式2 的值永远是真的，从而，f o r循环语句
for  ( ; ; )   {
…
}
就是一个“无限”循环语句，这种语句要用其他手段（如b r e a k语句或r e t u r n语句）才能终止执行。

 

 

例子：atoi 函数的实现，将字符转化为数字，除去前面的空白字符，处理+ - 操作，

#include  <ctype.h>
/* atoi：将s转换成整数；第2版*/
int atoi ( char  s[ ])
{
        int  i, n , sign;
        for ( i = 0;  isspace ( s[i] );  i++ )   /* 跳过空白字符*/

                 ;
         sign =  ( s[i] == '-' ) ? -1 : 1;
         if  (s[i] == '+' || s[i] == '-' )    /* 跳过符号*/
                      i++;
         for  ( n = 0;  isdigit ( s[i] );  i++)
                   n = 10 * n + (s[i] - '0' );
         return  sign * n;
}

 

shell排序：

/* shellsort：以递增顺序对v[0]、v[1]、……、v[n-1] 进行排序*/
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;
                    }
        }

}

 

将整型转化为字符串itoa的实现：

void itoa ( int n, char s[ ] );
{
    int i, sign;
    if ( ( sign = n ) < 0 ) /* 记录符号 */
          n = -n; /* 使n成为正数 */
    i = 0;

   do { /* 以反序生成数字 */
           s[i++] = n % 10 + '0'; /* 取下一个数字 */
   } while ( (n /= 10) > 0); /* 删除该数字 */
   if (sign < 0)
          s[i++] = '-';
   s[i] = '\0';
   reverse(s);
}
因为即使n为0也要至少把一个字符放到数组 s中，所以在这里有必要使用 d o - w h i l e语句，至
少使用d o - w h i l e语句要方便一些。

 

atof 将字符串转化为浮点数 比如123.45  ---与atoi相比，在小数点.之后开始记录小数点位数pow*=10.0

/* 把字符串s转换成相应的双精度浮点数 */
     double atof( char s[ ])
   {
       double val, power;
       int i, sign;
        for ( i = 0; isspace(s[i]); i++ ) /* 跳过空白 */
              ;
        sign = (s[i] == '-' ) ? -1 : 1;   

        if ( s[i] == '+' || s[i] == '-' )
            i++;
        for (val = 0.0; isdigit(s[i]); i++)

               val = 10.0 * val +(s[i] -'0' );
        if (s [i] ] = = '.')
              i++;
        for ( power = 1.0; isdigit(s[i]); i++) {
                 val = 10.0 * val +(s[i] -'0' );
                 power *= 10.0;
        }
       return sign * val / power;
   }

 

练习3-4     在数的对二的补码表示中，上面的itoa函数不能处理最大的负数-2的(字长-1)次方

的情况。解释其原因，并修改函数使它在任何机器上运行时都能打印出正确的值。

答：

例如char字长为8位，则对二补码范围为-128~127。

128的二进制源码为10000000，-128通过补码的负数转换规则也得到10000000，即-128二进制码为80（可用prinf("%hhx);验证）。即-128的二进制表示实际上市128，所以值为-128的char，n=-n;后值仍为-128。

修改函数，不将n转为正数，而是将每次取模运算的结果转为正数。从而避开无法将最大负数转为正数的问题。

#include <stdio.h>

#define abs(x) ((x) < 0 ? -(x) : (x))
void itoa(int n, char s[])
{
     int i, sign;
     sign = n;

     i = 0;
     do {
          s[i++] = abs(n % 10) + '0';
     } while ((n /= 10) != 0);

     if (sign < 0)
          s[i++] = '-';
     s[i] = '\0';
     //reverse(s);     
}
main()
{
     char s[20];
     itoa(10, s);
     printf("%s\n", s);
     itoa(-128, s);
     printf("%s\n", s);
}

练习3-5     编写函数itob(n, s, b)，将整数n转换为以b为底的数，并将转换结果以字符的形式

保存到字符串s中。例如，itob(n, s, 16)把整数n格式化为十六进制整数保存在s中。

答：

#include <stdio.h>
#include "reverse.c"
#define abs(x) (x) < 0 ? -(x) : (x)

void itob(int n, char s[], int b)
{
     int i, x, sign;
     sign = n;
     i = 0;
     do {
          x = abs(n % b);
          if (x >= 10)
               s[i++] = (x - 10) + 'A';
          else
               s[i++] = x + '0';
     } while ((n /= b) != 0);
     if (sign < 0)
          s[i++] = '-';
     s[i] = '\0';
     reverse(s);
}
main()
{
     char s[20];
     itob(29, s, 2);     
     printf("%s\n", s);

     itob(-257, s, 16);
     printf("%s\n", s);
}

练习 3-6     修改itoa函数，使得该函数可以接收三个参数。第三个参数为最小字段宽度。

为了保证转换后结果至少具有第三个参数指定的最小宽度，必要时在结果左边填充一定的空格。

答：

...

if (sign < 0)

     s[i++] = '-';

while (i <= w-1)     // fill space

     s[i++] = ' ';

...

3.7 break和continue语句

 

   在f o r循环语句中，c o n t i n u e语句的执行则意味着使控制传递到增量部分。 c o n t i n u e语句只
能用于循环语句，不能用于 s w i t c h语句。如果某个 c o n t i n u e语句位于s w i t c h语句中，而后者又位
于循环语句中，那么该c o n t i n u e语句用于控制下一次循环。

 

 在循环的某些部分比较复杂时常常要使用 c o n t i n u e语句。如果不使用 c o n t i n u e语句，那么就
可能要把测试反过来，或嵌入另一层循环，而这又会使程序的嵌套更深。

 

 

3.8 goto语句与标号

最常见的用法是在某些深度嵌套的结构中放弃处理，例如一次中止两层或多层循环。 b r e a k语句不能直接用于这一目的，它只能用于从最内层循环退出。下面是使用g o t o语句的一个例子：
for ( ⋯ )
      for ( ⋯ ) {
             ⋯
             if (disaster)
                   goto error;
      }
       ⋯
      error:
          清理操作
如果错误处理比较重要并且在好几个地方都会出现错误，那么使用这种组织就比较灵活方便。
标号的形式与变量名字相同，其后要跟一个冒号。标号可以用在任何语句的前面，但要与
相应的g o t o语句位于同一函数中。标号的作用域是整个函数

 

看一个例子，考虑判定在两个数组 a与b中是否具有相同元素的问题。一种可能的解决方
法是：
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i] == b[j])
第3章 控 制 流计计 53
下载
goto found;
/* 没有找到相同元素 */
⋯
found:
/* 取一个满足a[i] ==b[j]的元素 */
⋯
所有带有g o t o语句的程序代码都可以改写成不包含 g o t o语句的程序，但这可能需要以增加一
些额外的重复测试或变量为代价。例如，可将这个判定数组元素是否相同的程序段改写成如下
形式：
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)
/* 取一个满足a[i-1] ==b[j-1]的元素 */
⋯
else
/* 没有找到相同元素 */
⋯
除了以上介绍的几个程序段外，依赖于 g o t o语句的程序段一般都比不使用 g o t o语句的程序段
难以理解与维护。虽然不特别强调这一点，但我们还是建议尽可能减少 g o t o语句的使用。