Input and Output#

Streams#

C handles input and output using streams. One can think of them as three pipes. We have access to one end of each pipe and the operating system has access to the other:
- Whatever is placed at the other end of an input stream, makes its way to our end.
- Whatever we place at our end of an output stream, makes its way to the operating system's end.

Functionality for operating with streams is provided by the <stdio.h> header.

Input#

Reading from an input stream is most commonly done using the fscanf function:

int fscanf(FILE * restrict stream, const char * restrict format, ...);

The fscanf function reads from the stream pointed to by stream, interprets the read data according to format and stores it using the subsequent arguments as pointers to the locations which should receive the converted data.

The format string can be comprised of three types of directives: whitespace characters, non-whitespace characters and conversion specification. The fscanf function goes through these directives one by one and tries to interpret the data from stream accordingly. It terminates once it has gone through all directives or if a directive fails to match data from stream:
- A directive composed of one or more whitespace characters tells fscanf to read and discard the data from stream until a non-whitespace character is encountered in stream or there are no more characters to be read. Such directives never fail.
- A directive which is a sequence of \(n\) ordinary, non-whitespace characters tells fscanf read the next \(n\) characters from stream and compare them with the sequence in format. If the sequences do not match, then the directive fails, but the differing and subsequent characters remain in stream. The directive also fails if an EOF is reached or there is an encoding error or other read error.
- A conversion specification directive is used to match a pattern of characters in stream and interpret them in a specific way so as to be stored at the locations specified by the additional arguments.

A conversion specification has the following syntax:

%[*][width][length]specifier

The fields in [] are optional and are not literally separated by brackets in the format string.

If the * is present, then no argument should be provided for this conversion specification. The execution of fscanf remains unaltered, but the interpreted value is discarded and not stored anywhere.

The width field is a positive decimal integer which specifies the maximum number of characters to read as part of this conversion specification.

The specifier field is mandatory and describes the pattern to be matched:

The length field can be used to modify how the corresponding argument of the conversion specification is to be treated:

The fscanf function returns EOF if it fails before any conversion specification is completed. Otherwise, it returns the number of input assignments it performed, which is greater than or equal to zero.

Output#

The most common way to write to a stream is using the fprintf function:

int printf(const char *format, ...);

The printf function takes a string format and a variable number of arguments. The string format is what ultimately gets written to stdout, but it is first interpreted and modified by printf. This allows us to provide additional data to printf and also specify how this data should be formatted.

This formatting is done using format specifiers in format. The first additional argument corresponds to the first specifier, the second argument to the second specifier and so on. Therefore, the number of additional arguments must be at least as much as the number of specifiers. Additional arguments are ignored.

These specifiers have the following syntax:

%[flags][width][precision][length]specifier

Everything in [] is optional. The fields themselves have the following possible values:

The width field is optional and can be used to specify the minimum number of characters to be printed:

The precisionfield is used to specify the precision with which the number is to be printed:

The length field specifies as what data type the argument should be interpreted:

Standard I / O#

C provides three standard streams for input and output: standard input (stdin), standard output (stdout) and standard error (stderr).
- Whatever is placed at the other end of stdin, makes its way to our end.
- Whatever we place at our end of stdout or stderr, makes its way to the other end, respectively.

Most commonly, all three streams end up in the console, but it may also be a file or a network socket and it is also not necessary that all streams end up in the same place.

Standard Input#

Reading from stdin is most commonly done using the scanf function:

int scanf ( const char * format, ... );

It behaves in the same way as fscanf, but stream is automatically set to stdin.

Standard Output#