next up previous
Next: Structure of a C Up: Scientific programming in C Previous: Library functions


Data input and output

Data input and output operations in C are carried out by the standard input/output library (header file: stdio.h) via the functions scanf, printf, fscanf, and fprintf, which read and write data from/to the terminal, and from/to a data file, respectively. The additional functions fopen and fclose open and close, respectively, connections between a C program and a data file. In the following, these functions are described in detail.

The scanf function reads data from standard input (usually, the terminal). A call to this function takes the general form

scanf(control_string,  arg1,  arg2,  arg3,  ...)
where control_string refers to a character string containing certain required formatting information, and arg1, arg2, etc., are arguments that represent the individual input data items.

The control string consists of individual groups of characters, with one character group for each data input item. In its simplest form, each character group consists of a percent sign (%), followed by a set of conversion characters which indicate the type of the corresponding data item. The two most useful sets of conversion characters are as follows:

Character      Type
---------      ----

d              int
lf             double
The arguments are a set of variables whose types match the corresponding character groups in the control string. For reasons which will become apparent later on, each variable name must be preceded by an ampersand (&). Below is a typical application of the scanf function:
#include  <stdio.h>
. . . 
int  k;
double  x, y;
. . .
scanf("%d %lf %lf", &k, &x, &y);
. . .
In this example, the scanf function reads an integer value and two floating-point values, from standard input, into the integer variable k and the two floating-point variables x and y, respectively.

The scanf function returns an integer equal to the number of data values successfully read from standard input, which can be fewer than expected, or even zero, in the event of a matching failure. The special value EOF (which on most systems corresponds to $-1$) is returned if an end-of-file is reached before any attempted conversion occurs. The following code snippet gives an example of how the scanf function can be checked for error-free input:

#include  <stdio.h>
. . . 
int  check_input;
double  x, y, z;
. . .
check_input = scanf("%lf %lf %lf", &x, &y, &z);
if (check_input < 3)
 {
  printf("Error during data input\n");
  . . .
 }
. . .
See later for an explanation of the if() construct.

The printf function writes data to standard output (usually, the terminal). A call to this function takes the general form

printf(control_string,  arg1,  arg2,  arg3,  ...)
where control_string refers to a character string containing formatting information, and arg1, arg2, etc., are arguments that represent the individual output data items.

The control string consists of individual groups of characters, with one character group for each output data item. In its simplest form, each character group consists of a percent sign (%), followed by a conversion character which controls the format of the corresponding data item. The most useful conversion characters are as follows:

Character      Meaning
---------      -------

d              Display data item as signed decimal integer
f              Display data item as floating-point number without exponent
e              Display data item as floating-point number with exponent
The arguments are a set of variables whose types match the corresponding character groups in the control string (i.e., type int for d format, and type double for f or e format). In contrast to the scanf function, the arguments are not preceded by ampersands. Below is a typical application of the scanf function:
#include  <stdio.h>
. . . 
int  k = 3;
double  x = 5.4, y = -9.81;
. . .
printf("%d %f %f\n", k, x, y);
. . .
In this example, the program outputs the values of the integer variable k and the floating-point variables x and y to the terminal. Executing the program produces the following output:
3 5.400000 -9.810000   
%
Note that the purpose of the escape sequence \n in the control string is to generate a line-feed after the three data items have been written to the terminal.

Of course, the printf function can also be used to write a simple text string to the terminal: e.g.,

printf(text_string)
Ordinary text can also be incorporated into the control string described above.

An example illustrating somewhat more advanced use of the printf function is given below:

#include  <stdio.h>
. . . 
int  k = 3;
double  x = 5.4, y = -9.81;
. . .
printf("k = %3d  x + y = %9.4f  x*y = %11.3e\n", k, x + y, x*y);
. . .
Executing the program produces the following output:
k =   3  x + y =   -4.4100  x*y =  -5.297e+01        
%
Note that the final two arguments of the printf function are arithmetic expressions. Note, also, the incorporation of explanatory text into the control string.

The character sequence %3d in the control string indicates that the associated data item should be output as a signed decimal integer occupying a field whose width is at least 3 characters. More generally, the character sequence %nd indicates that the associated data item should be output as a signed decimal integer occupying a field whose width is at least n characters. If the number of characters in the data item is less than n characters, then the data item is preceded by enough leading blanks to fill the specified field. On the other hand, if the data item exceeds the specified field width then additional space is allocated to the data item, such that the entire data item is displayed.

The character sequence %9.4f in the control string indicates that the associated data item should be output as a floating-point number, in non-scientific format, which occupies a field of at least 9 characters, and has 4 figures after the decimal point. More generally, the character sequence %n.mf indicates that the associated data item should be output as a floating-point number, in non-scientific format, which occupies a field of at least n characters, and has m figures after the decimal point.

Finally, the character sequence %11.3e in the control string indicates that the associated data item should be output as a floating-point number, in scientific format, which occupies a field of at least 11 characters, and has 3 figures after the decimal point. More generally, the character sequence %n.me indicates that the associated data item should be output as a floating-point number, in scientific format, which occupies a field of at least n characters, and has m figures after the decimal point.

The printf function returns an integer equal to the number of printed characters, or a negative value if there was an output error.

When working with a data file, the first step is to establish a buffer area, where information is temporarily stored whilst being transferred between the program and the file. This buffer area allows information to be read or written to the data file in question more rapidly than would otherwise be possible. A buffer area is established by writing

FILE *stream;
where FILE (upper-case letters required) is a special structure type that establishes a buffer area, and stream is the identifier of the created buffer area. Note that a buffer area is often referred to as an input/output stream. The meaning of the asterisk (*) that precedes the identifier of the stream, in the above statement, will become clear later on. It is, of course, possible to establish multiple input/output streams (provided that their identifiers are distinct).

A data file must be opened and attached to a specific input/output stream before it can be created or processed. This operation is performed by the function fopen. A typical call to fopen takes the form

stream = fopen(file_name, file_type);
where stream is the identifier of the input/output stream to which the file is to be attached, and file_name and file_type are character strings that represent the name of the data file and the manner in which the data file will be utilized, respectively. The file_type string must be one of the strings listed below:
file_type         Meaning
---------         -------

"r"        Open existing file for reading only
"w"        Open new file for writing only (Any existing file 
            will be overwritten)
"a"        Open existing file in append mode. (Output will be
            appended to the file)
The fopen function returns the integer value NULL (which on most systems corresponds to zero) in the event of an error.

A data file must also be closed at the end of the program. This operation is performed by the function fclose. The syntax for a call to fclose is simply

fclose(stream);
where stream is the name of the input/output stream which is to be deattached from a data file. The fclose function returns the integer value 0 upon successful completion, otherwise it returns the special value EOF.

Data can be read from an open data file using the fscanf function, whose syntax is

fscanf(stream, control_string,  arg1,  arg2,  arg3,  ...)
Here, stream is the identifier of the input/output stream to which the file is attached, and the remaining arguments have exactly the same format and meaning as the corresponding arguments for the scanf function. The return values of fscanf are similar to those of the scanf function.

Likewise, data can be written to an open data file using the fprintf function, whose syntax is

fprintf(stream, control_string,  arg1,  arg2,  arg3,  ...)
Here, stream is the identifier of the input/output stream to which the file is attached, and the remaining arguments have exactly the same format and meaning as the corresponding arguments for the printf function. The return values of fprintf are similar to those of the printf function.

An example of a C program which outputs data to the file ``data.out'' is given below:

#include  <stdio.h>
. . .
int  k = 3;
double  x = 5.4, y = -9.81;
FILE *output;
. . .
output = fopen("data.out", "w");
if (output == NULL)
 {
  printf("Error opening file data.out\n");
  . . .
 }
. . .
fprintf(output, "k = %3d  x + y = %9.4f  x*y = %11.3e\n", k, x + y, x*y);
. . .
fclose(output);
. . .
On execution, the above program will write the line
k =   3  x + y =   -4.4100  x*y =  -5.297e+01
to the data file ``data.out''.


next up previous
Next: Structure of a C Up: Scientific programming in C Previous: Library functions
Richard Fitzpatrick 2006-03-29