1.2 Variables and Arithmetic Expressions 变量与算术表达式

The next program uses the formula ℃=(5/9)(℉-32) to print the following table of Fahrenheit temperatures and their centigrade or Celsius equivalents:

```   1    -17
20   -6
40   4
60   15
80   26
100  37
120  48
140  60
160  71
180  82
200  93
220  104
240  115
260  126
280  137
300  148```

The program itself still consists of the definition of a single function named main. It is longer than the one that printed "hello, world", but not complicated. It introduces several new ideas, including comments, declarations, variables, arithmetic expressions, loops , and formatted output.

```   1    #include <stdio.h>
2
3    /* print Fahrenheit-Celsius table
4        for fahr = 0, 20, ..., 300 */
5    main()
6    {
7      int fahr, celsius;
8      int lower, upper, step;
9
10      lower = 0;      /* lower limit of temperature scale */
11      upper = 300;    /* upper limit */
12      step = 20;      /* step size */
13
14      fahr = lower;
15      while (fahr <= upper) {
16          celsius = 5 * (fahr-32) / 9;
17          printf("%d\t%d\n", fahr, celsius);
18          fahr = fahr + step;
19      }
20    }
```

The two lines

```  /* print Fahrenheit-Celsius table
for fahr = 0, 20, ..., 300 */```

are a comment, which in this case explains briefly what the program does. Any characters between are ignored by the compiler; they may be used freely to make a program easier to understand. Comments may appear anywhere where a blank, tab or newline can.

```   1    -17
20   -6
40   4
60   15
80   26
100  37
120  48
140  60
160  71
180  82
200  93
220  104
240  115
260  126
280  137
300  148```

```   1 #include <stdio.h>
2
3 /* print Fahrenheit-Celsius table
4    for fahr = 0, 20, ..., 300 */
5 main()
6 {
7     int fahr, celsius;
8     int lower, upper, step;
9
10     lower = 0;      /* lower limit of temperature scale */
11     upper = 300;    /* upper limit */
12     step = 20;      /* step size */
13
14     fahr = lower;
15     while (fahr <= upper) {
16         celsius = 5 * (fahr-32) / 9;
17         printf("%d\t%d\n", fahr, celsius);
18         fahr = fahr + step;
19     }
20 }
```

```  /* print Fahrenheit-Celsius table
for fahr = 0, 20, ..., 300 */```

In C, all variables must be declared before they are used, usually at the beginning of the function before any executable statements. A declaration announces the properties of variables; it consists of a name and a list of variables, such as

```    int fahr, celsius;
int lower, upper, step;```

The type int means that the variables listed are integers; by contrast with float, which means floating point, i.e., numbers that may have a fractional part. The range of both int and float depends on the machine you are using; 16-bits ints, which lie between -32768 and +32767, are common, as are 32-bit ints. A float number is typically a 32-bit quantity, with at least six significant digits and magnitude generally between about 10-38 and 1038.

```    int fahr, celsius;
int lower, upper, step;```

C provides several other data types besides int and float, including:

``` char      character - a single byte
short     short integer
long      long integer
double    double-precision floating point ```

The size of these objects is also machine-dependent. There are also arrays, structures and unions of these basic types, pointers to them, and functions that return them, all of which we will meet in due course.

``` char      字符 - 一个字节
short     短整型
long      长整型
double    双精度浮点型```

Computation in the temperature conversion program begins with the assignment statements

```    lower = 0;
upper = 300;
step = 20;
fahr = lower;```

which set the variables to their initial values. Individual statements are terminated by semicolons.

```    lower = 0;
upper = 300;
step = 20;
fahr = lower;```

Each line of the table is computed the same way, so we use a loop that repeats once per output line; this is the purpose of the while loop

```    while (fahr <= upper) {
...
}```

The while loop operates as follows: The condition in parentheses is tested. If it is true (fahr is less than or equal to upper), the body of the loop (the three statements enclosed in braces) is executed. Then the condition is re-tested, and if true, the body is executed again. When the test becomes false (fahr exceeds upper) the loop ends, and execution continues at the statement that follows the loop. There are no further statements in this program, so it terminates.

```while (fahr <= upper) {
...
}```

while循环语句的执行方式是这样的：首先测试圆括号中的条件；如果条件为真(fahr<=upper)，则执行循环体(括在花括导中的3条语句)；然后再重新测试圆括号中的条件，如果为真，则再次执行循环体；当圆括号中的条件测试结果为假(fahr>upper)时，循环结束，并继续执行跟在while循环语句之后的下一条语句。在本程序中，循环语句后没有其他语句，因此整个程序的执行终止。

The body of a while can be one or more statements enclosed in braces, as in the temperature converter, or a single statement without braces, as in

```   while (i < j)
i = 2 * i;```

In either case, we will always indent the statements controlled by the while by one tab stop (which we have shown as four spaces) so you can see at a glance which statements are inside the loop. The indentation emphasizes the logical structure of the program. Although C compilers do not care about how a program looks, proper indentation and spacing are critical in making programs easy for people to read. We recommend writing only one statement per line, and using blanks around operators to clarify grouping. The position of braces is less important, although people hold passionate beliefs. We have chosen one of several popular styles. Pick a style that suits you, then use it consistently.

while语句的循环体可以是用花括号括起来的一条或多条语句(如上画的温度转换程序)，也可以是不用花括号包括的单条语句，例如：

```while (i < j)
i = 2 * i;```

Most of the work gets done in the body of the loop. The Celsius temperature is computed and assigned to the variable celsius by the statement

`        celsius = 5 * (fahr-32) / 9;`

The reason for multiplying by 5 and dividing by 9 instead of just multiplying by 5/9 is that in C, as in many other languages, integer division truncates: any fractional part is discarded. Since 5 and 9 are integers. 5/9 would be truncated to zero and so all the Celsius temperatures would be reported as zero.

`celsius = 5 * (fahr-32) / 9;`

This example also shows a bit more of how printf works. printf is a general-purpose output formatting function, which we will describe in detail in Chapter 7. Its first argument is a string of characters to be printed, with each % indicating where one of the other (second, third, ...) arguments is to be substituted, and in what form it is to be printed. For instance, %d specifies an integer argument, so the statement

`        printf("%d\t%d\n", fahr, celsius);`

causes the values of the two integers fahr and celsius to be printed, with a tab (\t) between them.

`printf("%d\t%d\n", fahr, celsius);`

Each % construction in the first argument of printf is paired with the corresponding second argument, third argument, etc.; they must match up properly by number and type, or you will get wrong answers.

printf函数的第一个参数中的各个%分别对应于第二个、第三个、……参数，它们在数目和类型上都必须匹配，否则将出现错误的结果。

By the way, printf is not part of the C language; there is no input or output defined in C itself. printf is just a useful function from the standard library of functions that are normally accessible to C programs. The behaviour of printf is defined in the ANSI standard, however, so its properties should be the same with any compiler and library that conforms to the standard.

In order to concentrate on C itself, we don't talk much about input and output until chapter 7. In particular, we will defer formatted input until then. If you have to input numbers, read the discussion of the function scanf in Section 7.4. scanf is like printf, except that it reads input instead of writing output.

There are a couple of problems with the temperature conversion program. The simpler one is that the output isn't very pretty because the numbers are not right-justified. That's easy to fix; if we augment each %d in the printf statement with a width, the numbers printed will be right-justified in their fields. For instance, we might say

`   printf("%3d %6d\n", fahr, celsius);`

to print the first number of each line in a field three digits wide, and the second in a field six digits wide, like this:

```     0     -17
20      -6
40       4
60      15
80      26
100      37
...```

The more serious problem is that because we have used integer arithmetic, the Celsius temperatures are not very accurate; for instance, 0oF is actually about -17.8oC, not -17. To get more accurate answers, we should use floating-point arithmetic instead of integer. This requires some changes in the program. Here is the second version:

```   1    #include <stdio.h>
2
3    /* print Fahrenheit-Celsius table
4        for fahr = 0, 20, ..., 300; floating-point version */
5    main()
6    {
7      float fahr, celsius;
8      float lower, upper, step;
9
10      lower = 0;      /* lower limit of temperatuire scale */
11      upper = 300;    /* upper limit */
12      step = 20;      /* step size */
13
14      fahr = lower;
15      while (fahr <= upper) {
16          celsius = (5.0/9.0) * (fahr-32.0);
17          printf("%3.0f %6.1f\n", fahr, celsius);
18          fahr = fahr + step;
19      }
20    }
```

This is much the same as before, except that fahr and celsius are declared to be float and the formula for conversion is written in a more natural way. We were unable to use 5/9 in the previous version because integer division would truncate it to zero. A decimal point in a constant indicates that it is floating point, however, so 5.0/9.0 is not truncated because it is the ratio of two floating-point values.

`printf("%3d %6d\n", fahr, celsius);`

```     0     -17
20      -6
40       4
60      15
80      26
100      37
...```

```   1 #include <stdio.h>
2
3 /* print Fahrenheit-Celsius table
4    for fahr = 0, 20, ..., 300; floating-point version */
5 main()
6 {
7     float fahr, celsius;
8     float lower, upper, step;
9
10     lower = 0;      /* lower limit of temperatuire scale */
11     upper = 300;    /* upper limit */
12     step = 20;      /* step size */
13
14     fahr = lower;
15     while (fahr <= upper) {
16         celsius = (5.0/9.0) * (fahr-32.0);
17         printf("%3.0f %6.1f\n", fahr, celsius);
18         fahr = fahr + step;
19     }
20 }
```

If an arithmetic operator has integer operands, an integer operation is performed. If an arithmetic operator has one floating-point operand and one integer operand, however, the integer will be converted to floating point before the operation is done. If we had written (fahr-32), the 32 would be automatically converted to floating point. Nevertheless, writing floating-point constants with explicit decimal points even when they have integral values emphasizes their floating-point nature for human readers.

The detailed rules for when integers are converted to floating point are in Chapter 2. For now, notice that the assignment

`   fahr = lower;`

and the test

`   while (fahr <= upper)`

also work in the natural way - the int is converted to float before the operation is done.

`fahr = lower;`

`while (fahr <= upper)`

The printf conversion specification %3.0f says that a floating-point number (here fahr) is to be printed at least three characters wide, with no decimal point and no fraction digits. %6.1f describes another number (celsius) that is to be printed at least six characters wide, with 1 digit after the decimal point. The output looks like this:

```     0   -17.8
20    -6.7
40     4.4
...```

Width and precision may be omitted from a specification: %6f says that the number is to be at least six characters wide; %.2f specifies two characters after the decimal point, but the width is not constrained; and %f merely says to print the number as floating point.

``` %d      print as decimal integer
%6d     print as decimal integer, at least 6 characters wide
%f      print as floating point
%6f     print as floating point, at least 6 characters wide
%.2f    print as floating point, 2 characters after decimal point
%6.2f           print as floating point, at least 6 wide and 2 after decimal point ```

Among others, printf also recognizes %o for octal, %x for hexadecimal, %c for character, %s for character string and %% for itself.

printf中的转换说明%3.0f表明待打印的浮点数(即fahr)至少占3个字符宽，且不带小数点和小数部分；%6.1f表明另一个待打印的数(celsius)至少占6个字符宽，且小数点后面有1位数字。其输出如下所示：

```     0   -17.8
20    -6.7
40     4.4
...```

``` %d      按照十进制整型数打印
%6d     按照十进制整型数打印，至少6个字符宽
%f      按照浮点数打印
%6f     按照浮点数打印，至少6个字符宽
%.2f    按照浮点数打印，小数点后有两位小数
%6.2f   按照浮点数打印，至少6个字符宽，小数点后有两位小数```

Exercise 1-3. Modify the temperature conversion program to print a heading above the table.

Exercise 1-4. Write a program to print the corresponding Celsius to Fahrenheit table.

TCPL/1.02_Variables_and_Arithmetic_Expressions (last edited 2008-02-23 15:34:07 by localhost)

ch3n2k.com | Copyright (c) 2004-2022 czk.