chapter3.html

c语言编程-c语言作者的书。英文原版。非常好。

The <tt>for</tt> is preferable when there is a simple initialization and
increment since it keeps the loop control statements close together and
visible at the top of the loop. This is most obvious in
<pre>
   for (i = 0; i &lt; n; i++)
       ...
</pre>
which is the C idiom for processing the first <tt>n</tt> elements of an array,
the analog of the Fortran DO loop or the Pascal <tt>for</tt>. The analogy is not
perfect, however, since the index variable <tt>i</tt> retains its value when the
loop terminates for any reason. Because the components of the <tt>for</tt> are
arbitrary expressions, <tt>for</tt> loops are not restricted to arithmetic
progressions. Nonetheless, it is bad style to force unrelated computations
into the initialization and increment of a <tt>for</tt>, which are better
reserved for loop control operations.
<p>
As a larger example, here is another version of <tt>atoi</tt> for converting a
string to its numeric equivalent. This one is slightly more general than the
one in <a href="chapter3.html">Chapter 2</a>; it copes with optional leading white space
and an optional <tt>+</tt> or <tt>-</tt> sign. (<a href="chapter4.html">Chapter 4</a>
shows <tt>atof</tt>, which does the same conversion for floating-point numbers.)
<p>
The structure of the program reflects the form of the input:
<p>
<em>
&nbsp;&nbsp;skip white space, if any<br>
&nbsp;&nbsp;get sign, if any<br>
&nbsp;&nbsp;get integer part and convert it
</em>
<p>
Each step does its part, and leaves things in a clean state for the next. The
whole process terminates on the first character that could not be part of a
number.
<pre>
   #include &lt;ctype.h&gt;

   /* 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;
   }
</pre>
The standard library provides a more elaborate function <tt>strtol</tt>
for conversion of strings to long integers; see
<a href="appb.html#sb.5">Section 5 of Appendix B</a>.
<p>
The advantages of keeping loop control centralized are even more obvious when
there are several nested loops. The following function is a Shell sort for
sorting an array of integers. The basic idea of this sorting algorithm, which
was invented in 1959 by D. L. Shell, is that in early stages, far-apart
elements are compared, rather than adjacent ones as in simpler interchange
sorts. This tends to eliminate large amounts of disorder quickly, so later
stages have less work to do. The interval between compared elements is
gradually decreased to one, at which point the sort effectively becomes an
adjacent interchange method.
<pre>
   /* 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 &gt; 0; gap /= 2)
           for (i = gap; i &lt; 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;
               }
   }
</pre>
There are three nested loops. The outermost controls the gap between
compared elements, shrinking it from <tt>n/2</tt> by a factor of two each
pass until it becomes zero. The middle loop steps along the elements. The
innermost loop compares each pair of elements that is separated by <tt>gap</tt>
and reverses any that are out of order. Since <tt>gap</tt> is eventually reduced
to one, all elements are eventually ordered correctly. Notice how the
generality of the <tt>for</tt> makes the outer loop fit in the same form as the
others, even though it is not an arithmetic progression.
<p>
One final C operator is the comma ``<tt>,</tt>'', which most often finds use in
the <tt>for</tt> statement. A pair of expressions separated by a comma is
evaluated left to right, and the type and value of the result are the type
and value of the right operand. Thus in a for statement, it is possible to
place multiple expressions in the various parts, for example to process two
indices in parallel. This is illustrated in the function <tt>reverse(s)</tt>,
which reverses the string <tt>s</tt> in place.
<pre>
   #include &lt;string.h&gt;

   /* reverse:  reverse string s in place */
   void reverse(char s[])
   {
       int c, i, j;

       for (i = 0, j = strlen(s)-1; i &lt; j; i++, j--) {
           c = s[i];
           s[i] = s[j];
           s[j] = c;
       }
   }
</pre>
The commas that separate function arguments, variables in declarations, etc.,
are <em>not</em> comma operators, and do not guarantee left to right evaluation.
<p>
Comma operators should be used sparingly. The most suitable uses are for
constructs strongly related to each other, as in the <tt>for</tt> loop in
<tt>reverse</tt>, and in macros where a multistep computation has to be a single
expression. A comma expression might also be appropriate for the exchange of
elements in <tt>reverse</tt>, where the exchange can be thought of a single
operation:
<pre>
    for (i = 0, j = strlen(s)-1; i &lt; j; i++, j--)
           c = s[i], s[i] = s[j], s[j] = c;
</pre>
<strong>Exercise 3-3.</strong> Write a function <tt>expand(s1,s2)</tt> that expands
shorthand notations like <tt>a-z</tt> in the string <tt>s1</tt> into the equivalent
complete list <tt>abc...xyz</tt> in <tt>s2</tt>. Allow for letters of either case
and digits, and be prepared to handle cases like <tt>a-b-c</tt> and <tt>a-z0-9</tt>
and <tt>-a-z</tt>. Arrange that a leading or trailing <tt>-</tt> is taken
literally.

<h2><a name="s3.6">3.6 Loops - Do-While</a></h2>
As we discussed in <a href="chapter1.html">Chapter 1</a>, the <tt>while</tt>
and <tt>for</tt> loops test the termination condition at the top. By contrast,
the third loop in C, the <tt>do-while</tt>, tests at the bottom <em>after</em>
making each pass through the loop body; the body is always executed at least
once.
<p>
The syntax of the <tt>do</tt> is
<pre>
   do
       <em>statement</em>
   while (<em>expression</em>);
</pre>
The <em>statement</em> is executed, then <em>expression</em> is evaluated. If
it is true, <em>statement</em> is evaluated again, and so on. When the expression
becomes false, the loop terminates. Except for the sense of the test,
<tt>do-while</tt> is equivalent to the Pascal <tt>repeat-until</tt> statement.
<p>
Experience shows that <tt>do-while</tt> is much less used than <tt>while</tt> and
<tt>for</tt>. Nonetheless, from time to time it is valuable, as in the following
function <tt>itoa</tt>, which converts a number to a character string (the inverse
of <tt>atoi</tt>). The job is slightly more complicated than might be thought at
first, because the easy methods of generating the digits generate them in the
wrong order. We have chosen to generate the string backwards, then reverse it.
<pre>
   /* itoa:  convert n to characters in s */
   void itoa(int n, char s[])
   {
       int i, sign;

       if ((sign = n) &lt; 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) &gt; 0);    /* delete it */
       if (sign &lt; 0)
           s[i++] = '-';
       s[i] = '\0';
       reverse(s);
   }
</pre>
The <tt>do-while</tt> is necessary, or at least convenient, since at least one
character must be installed in the array <tt>s</tt>, even if <tt>n</tt> is zero.
We also used braces around the single statement that makes up the body of the
<tt>do-while</tt>, even though they are unnecessary, so the hasty reader will not
mistake the <tt>while</tt> part for the <em>beginning</em> of a <tt>while</tt> loop.
<p>
<strong>Exercise 3-4.</strong> In a two's complement number representation, our version
of <tt>itoa</tt> does not handle the largest negative number, that is, the value
of <tt>n</tt> equal to -(2<sup>wordsize-1</sup>). Explain why not. Modify it to
print that value correctly, regardless of the machine on which it runs.
<p>
<strong>Exercise 3-5.</strong> Write the function <tt>itob(n,s,b)</tt> that converts the
integer <tt>n</tt> into a base <tt>b</tt> character representation in the string
<tt>s</tt>. In particular, <tt>itob(n,s,16)</tt> formats <tt>s</tt> as a hexadecimal
integer in <tt>s</tt>.
<p>
<strong>Exercise 3-6.</strong> Write a version of <tt>itoa</tt> that accepts
three arguments instead of two. The third argument is a minimum field width;
the converted number must be padded with blanks on the left if necessary to
make it wide enough.

<h2><a name="s3.7">3.7 Break and Continue</a></h2>
It is sometimes convenient to be able to exit from a loop other than by
testing at the top or bottom. The <tt>break</tt> statement provides an early
exit from <tt>for</tt>, <tt>while</tt>, and <tt>do</tt>, just as from <tt>switch</tt>.
A <tt>break</tt> causes the innermost enclosing loop or <tt>switch</tt> to be
exited immediately.
<p>
The following function, <tt>trim</tt>, removes trailing blanks, tabs and
newlines from the end of a string, using a <tt>break</tt> to exit from a loop
when the rightmost non-blank, non-tab, non-newline is found.
<pre>
   /* trim:  remove trailing blanks, tabs, newlines */
   int trim(char s[])
   {
       int n;

       for (n = strlen(s)-1; n &gt;= 0; n--)
           if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
               break;
       s[n+1] = '\0';
       return n;
   }
</pre>
<tt>strlen</tt> returns the length of the string. The <tt>for</tt> loop starts at the
end and scans backwards looking for the first character that is not a blank or
tab or newline. The loop is broken when one is found, or when <tt>n</tt> becomes
negative (that is, when the entire string has been scanned). You should verify
that this is correct behavior even when the string is empty or contains only
white space characters.
<p>
The <tt>continue</tt> statement is related to <tt>break</tt>, but less often used;
it causes the next iteration of the enclosing <tt>for</tt>, <tt>while</tt>, or
<tt>do</tt> loop to begin. In the <tt>while</tt> and <tt>do</tt>, this means that the test
part is executed immediately; in the <tt>for</tt>, control passes to the increment
step. The <tt>continue</tt> statement applies only to loops, not to <tt>switch</tt>.
A <tt>continue</tt> inside a <tt>switch</tt> inside a loop causes the next loop
iteration.
<p>
As an example, this fragment processes only the non-negative elements in the
array <tt>a</tt>; negative values are skipped.
<pre>
   for (i = 0; i &lt; n; i++)
       if (a[i] &lt; 0)   /* skip negative elements */
           continue;
       ... /* do positive elements */
</pre>
The <tt>continue</tt> statement is often used when the part of the loop that
follows is complicated, so that reversing a test and indenting another level
would nest the program too deeply.

<h2><a name="s3.8">3.8 Goto and labels</a></h2>
C provides the infinitely-abusable <tt>goto</tt> statement, and labels to branch
to. Formally, the <tt>goto</tt> statement is never necessary, and in practice it
is almost always easy to write code without it. We have not used <tt>goto</tt>
in this book.
<p>
Nevertheless, there are a few situations where <tt>goto</tt>s may find a place.
The most common is to abandon processing in some deeply nested structure, such
as breaking out of two or more loops at once. The <tt>break</tt> statement cannot
be used directly since it only exits from the innermost loop. Thus:
<pre>
       for ( ... )
           for ( ... ) {
               ...
               if (disaster)
                   goto error;
           }
       ...
   error:
       /* clean up the mess */
</pre>
This organization is handy if the error-handling code is non-trivial, and if
errors can occur in several places.
<p>
A label has the same form as a variable name, and is followed by a colon. It
can be attached to any statement in the same function as the <tt>goto</tt>.
The scope of a label is the entire function.
<p>
As another example, consider the problem of determining whether two arrays
<tt>a</tt> and <tt>b</tt> have an element in common. One possibility is
<pre>
       for (i = 0; i &lt; n; i++)
           for (j = 0; j &lt; m; j++)
               if (a[i] == b[j])
                   goto found;
       /* didn't find any common element */
       ...
   found:
       /* got one: a[i] == b[j] */
       ...
</pre>
Code involving a <tt>goto</tt> can always be written without one, though perhaps
at the price of some repeated tests or an extra variable. For example, the
array search becomes
<pre>
   found = 0;
   for (i = 0; i &lt; n && !found; i++)
       for (j = 0; j &lt; 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 */
       ...
</pre>
With a few exceptions like those cited here, code that relies on <tt>goto</tt>
statements is generally harder to understand and to maintain than code without
<tt>goto</tt>s. Although we are not dogmatic about the matter, it does seem that
<tt>goto</tt> statements should be used rarely, if at all.

<p>
<hr>
<p align="center">
<a href="chapter2.html">Back to Chapter 2</a>&nbsp;--&nbsp;
<a href="kandr.html">Index</a>&nbsp;--&nbsp;
<a href="chapter4.html">Chapter 4</a>
<p>
<hr>

</body>
</html>