Author : Brian Kernighan
Page : 1 Next >>
Brian W. Kernighan
Bell Laboratories, Murray Hill, N. J.
C is a computer language available on the GCOS and UNIX
operating systems at Murray Hill and (in preliminary form)
on OS/360 at Holmdel. C lets you write your programs
clearly and simply _ it has decent control flow facilities
so your code can be read straight down the page, without
labels or GOTO's; it lets you write code that is compact
without being too cryptic; it encourages modularity and good
program organization; and it provides good data-structuring
facilities.
This memorandum is a tutorial to make learning C as
painless as possible. The first part concentrates on the
central features of C; the second part discusses those parts
of the language which are useful (usually for getting more
efficient and smaller code) but which are not necessary for
the new user. This is "not" a reference manual. Details and
special cases will be skipped ruthlessly, and no attempt
will be made to cover every language feature. The order of
presentation is hopefully pedagogical instead of logical.
Users who would like the full story should consult the 'C
Reference Manual' by D. M. Ritchie [1], which should be read
for details anyway. Runtime support is described in [2] and
[3]; you will have to read one of these to learn how to com-
pile and run a C program.
We will assume that you are familiar with the mysteries
of creating files, text editing, and the like in the operat-
ing system you run on, and that you have programmed in some
language before.
main( ) {
printf("hello, world");
}
A C program consists of one or more functions, which
are similar to the functions and subroutines of a Fortran
program or the procedures of PL/I, and perhaps some external
data definitions. main is such a function, and in fact all
C programs must have a main. Execution of the program
begins at the first statement of main. main will usually
invoke other functions to perform its job, some coming from
the same program, and others from libraries.
One method of communicating data between functions is
by arguments. The parentheses following the function name
surround the argument list; here main is a function of no
arguments, indicated by ( ). The {} enclose the statements
of the function. Individual statements end with a semicolon
but are otherwise free-format.
printf is a library function which will format and
print output on the terminal (unless some other destination
is specified). In this case it prints
hello, world
A function is invoked by naming it, followed by a list of
arguments in parentheses. There is no CALL statement as in
Fortran or PL/I.
Here's a bigger program that adds three integers and
prints their sum.
main( ) {
int a, b, c, sum;
a = 1; b = 2; c = 3;
sum = a + b + c;
printf("sum is %d", sum);
}
Arithmetic and the assignment statements are much the
same as in Fortran (except for the semicolons) or PL/I. The
format of C programs is quite free. We can put several
statements on a line if we want, or we can split a statement
among several lines if it seems desirable. The split may be
between any of the operators or variables, but NOT in the
middle of a name or operator. As a matter of style, spaces,
tabs, and newlines should be used freely to enhance reada-
bility.
C has four fundamental types of variables:
int integer (PDP-11: 16 bits; H6070: 36 bits; IBM360: 32 bits)
char one byte character (PDP-11, IBM360: 8 bits; H6070: 9 bits)
float single-precision floating point
double double-precision floating point
There are also arrays and structures of these basic types,
pointers to them and functions that return them, all of
which we will meet shortly.
All variables in a C program must be declared, although
this can sometimes be done implicitly by context. Declara-
tions must precede executable statements. The declaration
int a, b, c, sum;
declares a, b, c, and sum to be integers.
Variable names have one to eight characters, chosen
from A-Z, a-z, 0-9, and _, and start with a non-digit.
Stylistically, it's much better to use only a single case
and give functions and external variables names that are
unique in the first six characters. (Function and external
variable names are used by various assemblers, some of which
are limited in the size and case of identifiers they can
handle.) Furthermore, keywords and library functions may
only be recognized in one case.
We have already seen decimal integer constants in the
previous example _ 1, 2, and 3. Since C is often used for
system programming and bit-manipulation, octal numbers are
an important part of the language. In C, any number that
begins with 0 (zero!) is an octal integer (and hence can't
have any 8's or 9's in it). Thus 0777 is an octal constant,
with decimal value 511.
A ``character'' is one byte (an inherently machine-
dependent concept). Most often this is expressed as a character
constant, which is one character enclosed in single
quotes. However, it may be any quantity that fits in a
byte, as in flags below:
char quest, newline, flags;
quest = '?';
newline = '\n';
flags = 077;
The sequence `\n' is C notation for ``newline charac-
ter'', which, when printed, skips the terminal to the begin-
ning of the next line. Notice that `\n' represents only a
single character. There are several other ``escapes'' like
`\n' for representing hard-to-get or invisible characters,
such as `\t' for tab, `\b' for backspace, `\0' for end of
file, and `\\' for the backslash itself.
float and double constants are discussed in section 26.
main( ) {
char c;
c = getchar( );
putchar(c);
}
getchar and putchar are the basic I/O library functions
in C. getchar fetches one character from the standard input
(usually the terminal) each time it is called, and returns
that character as the value of the function. When it
reaches the end of whatever file it is reading, thereafter
it returns the character represented by `\0' (ascii NUL,
which has value zero). We will see how to use this very
shortly.
putchar puts one character out on the standard output
(usually the terminal) each time it is called. So the pro-
gram above reads one character and writes it back out. By
itself, this isn't very interesting, but observe that if we
put a loop around this, and add a test for end of file, we
have a complete program for copying one file to another.
Page : 1 Next >>