What Is The Variables
and Arithmetic Expressions
The next program uses the formula oC=(5/9)(oF-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.
#include /* print Fahrenheit-Celsius
table for fahr = 0, 20, ..., 300 */ main() { int fahr, celsius; int lower,
upper, step; lower = 0; /* lower limit of temperature scale */ upper = 300; /*
upper limit */ step = 20; /* step size */ fahr = lower; while (fahr <=
upper) { celsius = 5 * (fahr-32) / 9; printf("%d\t%d\n", fahr,
celsius); fahr = fahr + step; } }
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 /* and */ 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.
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. 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. Computation in the temperature
conversion program begins with the
assignment statements
lower = 0;
upper = 300;
step = 20;
which set the variables to their initial values.
Individual statements are terminated by semicolons. 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. 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
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.
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 Input and Output
Lesson. 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. 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. 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 Input and
Output Lesson. 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 36
….
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:
#include
/* print
Fahrenheit-Celsius table
for fahr = 0, 20, ..., 300; floating-point version */
main()
{
float fahr,
celsius;
float lower, upper, step;
lower = 0; /* lower limit of temperatuire scale */
upper = 300; /* upper
limit */
step = 20; /* step
size */
fahr = lower;
while (fahr <= upper) {
celsius = (5.0/9.0) * (fahr-32.0);
printf("%3.0f %6.1f\n", fahr, celsius);
fahr = fahr + step;
}
}
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. 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 Types, Operators
and Expressions. 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. 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.
Exercise Modify
the temperature conversion program to print a heading above the table.
Exercise Write
a program to print the corresponding Celsius to Fahrenheit table.
0 comments:
Post a Comment