chapter1.html

Kernighan and Ritchie - The C Programming Language c程序设计语言（第二版）称作是C语言学习的圣经

word per line.

<h2><a name="s1.6">1.6 Arrays</a></h2>
Let is write a program to count the number of occurrences of each digit, of
white space characters (blank, tab, newline), and of all other characters.
This is artificial, but it permits us to illustrate several aspects of C in
one program.
<p>
There are twelve categories of input, so it is convenient to use an array to
hold the number of occurrences of each digit, rather than ten individual
variables. Here is one version of the program:
<pre>
   #include &lt;stdio.h&gt;

   /* count digits, white space, others */
   main()
   {
       int c, i, nwhite, nother;
       int ndigit[10];

       nwhite = nother = 0;
       for (i = 0; i &lt; 10; ++i)
           ndigit[i] = 0;

       while ((c = getchar()) != EOF)
           if (c &gt;= '0' && c &lt;= '9')
               ++ndigit[c-'0'];
           else if (c == ' ' || c == '\n' || c == '\t')
               ++nwhite;
           else
               ++nother;

       printf("digits =");
       for (i = 0; i &lt; 10; ++i)
           printf(" %d", ndigit[i]);
       printf(", white space = %d, other = %d\n",
           nwhite, nother);
   }
</pre>
The output of this program on itself is
<pre>
   digits = 9 3 0 0 0 0 0 0 0 1, white space = 123, other = 345
</pre>
The declaration
<pre>
   int ndigit[10];
</pre>
declares <tt>ndigit</tt> to be an array of 10 integers. Array subscripts always
start at zero in C, so the elements are <tt>ndigit[0], ndigit[1], ...,
ndigit[9]</tt>. This is reflected in the <tt>for</tt> loops that initialize
and print the array.
<p>
A subscript can be any integer expression, which includes integer variables
like <tt>i</tt>, and integer constants.
<p>
This particular program relies on the properties of the character
representation of the digits. For example, the test
<pre>
   if (c &gt;= '0' && c &lt;= '9')
</pre>
determines whether the character in <tt>c</tt> is a digit. If it is, the
numeric value of that digit is
<pre>
   c - '0'
</pre>
This works only if <tt>'0', '1', ..., '9'</tt> have consecutive increasing
values. Fortunately, this is true for all character sets.
<p>
By definition, <tt>char</tt>s are just small integers, so <tt>char</tt>
variables and constants are identical to <tt>int</tt>s in arithmetic
expressions. This is natural and convenient; for example <tt>c-'0'</tt> is an
integer expression with a value between 0 and 9 corresponding to the
character <tt>'0'</tt> to <tt>'9'</tt> stored in <tt>c</tt>, and thus a valid
subscript for the array <tt>ndigit</tt>.
<p>
The decision as to whether a character is a digit, white space, or something
else is made with the sequence
<pre>
   if (c &gt;= '0' && c &lt;= '9')
       ++ndigit[c-'0'];
   else if (c == ' ' || c == '\n' || c == '\t')
       ++nwhite;
   else
       ++nother;
</pre>
The pattern
<pre>
   if (<em>condition<sub>1</sub></em>)
       <em>statement<sub>1</sub></em>
   else if (<em>condition<sub>2</sub></em>)
       <em>statement<sub>2</sub></em>
       ...
       ...
   else
       <em>statement<sub>n</sub></em>
</pre>
occurs frequently in programs as a way to express a multi-way decision. The
<em>conditions</em> are evaluated in order from the top until some
<em>condition</em> is satisfied; at that point the corresponding
<em>statement</em> part is executed, and the entire construction is finished.
(Any <em>statement</em> can be several statements enclosed in braces.) If
none of the conditions is satisfied, the <em>statement</em> after the final
<tt>else</tt> is executed if it is present. If the final <tt>else</tt> and
<em>statement</em> are omitted, as in the word count program, no action takes
place. There can be any number of
<p>
<tt>else if</tt>(<em>condition</em>)<br>
&nbsp;&nbsp;<em>statement</em>
<p>
groups between the initial <tt>if</tt> and the final <tt>else</tt>.
<p>
As a matter of style, it is advisable to format this construction as we have
shown; if each <tt>if</tt> were indented past the previous <tt>else</tt>, a long
sequence of decisions would march off the right side of the page.
<p>
The <tt>switch</tt> statement, to be discussed in <a href="chapter4.html">Chapter 4</a>,
provides another way to write a multi-way branch that is particulary suitable
when the condition is whether some integer or character expression matches
one of a set of constants. For contrast, we will present a <tt>switch</tt>
version of this program in <a href="chapter3.html#s3.4">Section 3.4</a>.
<p>
<strong>Exercise 1-13.</strong> Write a program to print a histogram of the
lengths of words in its input. It is easy to draw the histogram with the bars
horizontal; a vertical orientation is more challenging.
<p>
<strong>Exercise 1-14.</strong> Write a program to print a histogram of the
frequencies of different characters in its input.

<h2><a name="s1.7">1.7 Functions</a></h2>
In C, a function is equivalent to a subroutine or function in Fortran, or a
procedure or function in Pascal. A function provides a convenient way to
encapsulate some computation, which can then be used without worrying about
its implementation. With properly designed functions, it is possible to
ignore <em>how</em> a job is done; knowing <em>what</em> is done is sufficient. C
makes the sue of functions easy,  convinient and efficient; you will often
see a short function defined and called only once, just because it clarifies
some piece of code.
<p>
So far we have used only functions like <tt>printf</tt>, <tt>getchar</tt> and
<tt>putchar</tt> that have been provided for us; now it's time to write a few
of our own. Since C has no exponentiation operator like the <tt>**</tt> of
Fortran, let us illustrate the mechanics of function definition by writing a
function <tt>power(m,n)</tt> to raise an integer <tt>m</tt> to a positive
integer power <tt>n</tt>. That is, the value of <tt>power(2,5)</tt> is 32.
This function is not a practical exponentiation routine, since it handles
only positive powers of small integers, but it's good enough for
illustration.(The standard library contains a function <tt>pow(x,y)</tt> that
computes <em>x<sup>y</sup></em>.)
<p>
Here is the function <tt>power</tt> and a main program to exercise it, so you
can see the whole structure at once.
<pre>
   #include &lt;stdio.h&gt;

   int power(int m, int n);

    /* test power function */
    main()
    {
        int i;

        for (i = 0; i &lt; 10; ++i)
            printf("%d %d %d\n", i, power(2,i), power(-3,i));
        return 0;
    }

    /* power:  raise base to n-th power; n &gt;= 0 */
    int power(int base, int n)
    {
        int i,  p;

        p = 1;
        for (i = 1; i &lt;= n; ++i)
            p = p * base;
        return p;
    }
</pre>
A function definition has this form:
<pre>
return-type function-name(parameter declarations, if any)
{
   declarations
   statements
}
</pre>
Function definitions can appear in any order, and in one source file or
several, although no function can be split between files. If the source
program appears in several files, you may have to say more to compile and
load it than if it all appears in one, but that is an operating system
matter, not a language attribute. For the moment, we will assume that both
functions are in the same file, so whatever you have learned about running C
programs will still work.
<p>
The function <tt>power</tt> is called twice by <tt>main</tt>, in the line
<pre>
   printf("%d %d %d\n", i, power(2,i), power(-3,i));
</pre>
Each call passes two arguments to <tt>power</tt>, which each time returns an
integer to be formatted and printed. In an expression, <tt>power(2,i)</tt> is an
integer just as <tt>2</tt> and <tt>i</tt> are. (Not all functions produce an
integer value; we will take this up in <a href="chapter4.html">Chapter 4</a>.)
<p>
The first line of <tt>power</tt> itself,
<pre>
    int power(int base, int n)
</pre>
declares the parameter types and names, and the type of the result that the
function returns. The names used by <tt>power</tt> for its parameters are local
to <tt>power</tt>, and are not visible to any other function: other routines
can use the same names without conflict. This is also true of the variables
<tt>i</tt> and <tt>p</tt>: the <tt>i</tt> in <tt>power</tt> is unrelated to
the <tt>i</tt> in <tt>main</tt>.
<p>
We will generally use <em>parameter</em> for a variable named in the
parenthesized list in a function. The terms <em>formal argument</em> and
<em>actual argument</em> are sometimes used for the same distinction.
<p>
The value that <tt>power</tt> computes is returned to <tt>main</tt> by the
<tt>return</tt>: statement. Any expression may follow <tt>return</tt>:
<pre>
   return <em>expression</em>;
</pre>
A function need not return a value; a return statement with no expression
causes control, but no useful value, to be returned to the caller, as does
``falling off the end'' of a function by reaching the terminating right
brace. And the calling function can ignore a value returned by a function.
<p>
You may have noticed that there is a <tt>return</tt> statement at the end of
<tt>main</tt>. Since <tt>main</tt> is a function like any other, it may return a
value to its caller, which is in effect the environment in which the program
was executed. Typically, a return value of zero implies normal termination;
non-zero values signal unusual or erroneous termination conditions. In the
interests of simplicity, we have omitted <tt>return</tt> statements from our
<tt>main</tt> functions up to this point, but we will include them hereafter, as
a reminder that programs should return status to their environment.
<p>
The declaration
<pre>
    int power(int base, int n);
</pre>
just before <tt>main</tt> says that <tt>power</tt> is a function that expects two
<tt>int</tt> arguments and returns an <tt>int</tt>. This declaration, which is
called a <em>function prototype</em>, has to agree with the definition and uses
of <tt>power</tt>. It is an error if the definition of a function or any uses of
it do not agree with its prototype.
<p>
parameter names need not agree. Indeed, parameter names are optional in a
function prototype, so for the prototype we could have written
<pre>
    int power(int, int);
</pre>
Well-chosen names are good documentation however, so we will often use them.
<p>
A note of history: the biggest change between ANSI C and earlier versions is
how functions are declared and defined. In the original definition of C, the
<tt>power</tt> function would have been written like this:
<pre>
   /* power:  raise base to n-th power; n &gt;= 0 */
   /*         (old-style version) */
   power(base, n)
   int base, n;
   {
       int i, p;

       p = 1;
       for (i = 1; i &lt;= n; ++i)
           p = p * base;
       return p;
   }
</pre>
The parameters are named between the parentheses, and their types are
declared before opening the left brace; undeclared parameters are taken as
<tt>int</tt>. (The body of the function is the same as before.)
<p>
The declaration of <tt>power</tt> at the beginning of the program would have
looked like this:
<pre>
    int power();
</pre>
No parameter list was permitted, so the compiler could not readily check that
<tt>power</tt> was being called correctly. Indeed, since by default <tt>power</tt>
would have been assumed to return an <tt>int</tt>, the entire declaration might
well have been omitted.
<p>
The new syntax of function prototypes makes it much easier for a compiler to
detect errors in the number of arguments or their types. The old style of
declaration and definition still works in ANSI C, at least for a transition
period, but we strongly recommend that you use the new form when you have a
compiler that supports it.
<p>
<strong>Exercise 1.15.</strong> Rewrite the temperature conversion program of
<a href="#s1.2">Section 1.2</a> to use a function for conversion.

<h2><a name="s1.8">1.8 Arguments - Call by Value</a></h2>
One aspect of C functions may be unfamiliar to programmers who are used to
some other languages, particulary Fortran. In C, all function arguments are
passed ``by value.'' This means that the called function is given the values
of its arguments in temporary variables rather than the originals. This leads
to some different properties than are seen with ``call by reference''
languages like Fortran or with <tt>var</tt> parameters in Pascal, in which the
called routine has access to the original argument, not a local copy.
<p>
Call by value is an asset, however, not a liability. It usually leads to more
compact programs with fewer extraneous variables, because parameters can be
treated as conveniently initialized local variables in the called routine.
For example, here is a version of <tt>power</tt> that makes use of this property.