The C library implements a simple model of text input and output. A text stream
consists of a sequence of lines; each line ends with a newline character. If the
system doesn't operate that way, the library does whatever necessary to make it
appear as if it does. For instance, the library might convert carriage return
and linefeed to newline on input and back again on output.
The simplest input mechanism is to read one character at a time from the standard
input, normally the keyboard, with getchar:
getchar returns the next input character each time it is called, or EOF
when it encounters end of file. The symbolic constant EOF is defined in
<stdio.h>. The value is typically -1, bus tests should be written
in terms of EOF so as to be independent of the specific value.
In many environments, a file may be substituted for the keyboard by using the
< convention for input redirection: if a program prog uses getchar,
then the command line
causes prog to read characters from infile instead. The
switching of the input is done in such a way that prog itself is
oblivious to the change; in particular, the string ``<infile'' is
not included in the command-line arguments in argv. Input switching is
also invisible if the input comes from another program via a pipe mechanism: on
some systems, the command line
otherprog | prog
runs the two programs otherprog and prog, and pipes the
standard output of otherprog into the standard input for prog.
is used for output: putchar(c) puts the character c on the standard
output, which is by default the screen. putchar returns the
character written, or EOF is an error occurs. Again, output can usually
be directed to a file with >filename: if prog uses putchar,
will write the standard output to outfile instead. If pipes are
prog | anotherprog
puts the standard output of prog into the standard input of anotherprog.
Output produced by printf also finds its way to the standard output.
Calls to putchar and printf may be interleaved - output
happens in the order in which the calls are made.
Each source file that refers to an input/output library function must contain
before the first reference. When the name is bracketed by < and > a search
is made for the header in a standard set of places (for example, on UNIX
systems, typically in the directory /usr/include).
Many programs read only one input stream and write only one output stream;
for such programs, input and output with getchar, putchar, and
printf may be entirely adequate, and is certainly enough to get
started. This is particularly true if redirection is used to connect the output
of one program to the input of the next. For example, consider the program lower,
which converts its input to lower case:
main() /* lower: convert input to lower case*/
while ((c = getchar()) != EOF)
The function tolower is defined in <ctype.h>; it
converts an upper case letter to lower case, and returns other characters
untouched. As we mentioned earlier, ``functions'' like getchar and putchar
in <stdio.h> and tolower in <ctype.h> are
often macros, thus avoiding the overhead of a function call per character.
Regardless of how the <ctype.h> functions are implemented on a
given machine, programs that use them are shielded from knowledge of the