Input and Output

Input and Output

The C language provides no direct facilities for input and output (IO), and, instead, these operations are supplied as functions in the standard library.

1.     Formatted IO

2.     File IO

3.     Command-Shell Redirection

4.     Command-Line Arguments

1.   Formatted IO

1.1Formatted Output: printf()

The function printf() is a general purpose print function that converts and formats its arguments to a character string, and prints the result to standard output (typically the screen). The general interface for printf() is

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

The first argument is a format string (The format string is composed of ordinary characters and conversion specification characters.), which defines the layout of the printed text.

This is followed by zero or more optional arguments, with the number of arguments, and their type, being determined by the contents of the format string.

The return value is the number of characters printed, unless an error occurs during output whereupon the return value is EOF.

Conversion specifications are identified by a % character followed by a number of optional fields and terminated by a type conversion character. A simple example is

printf("%d green %s sitting on a wall.\n", 10, "bottles");

where the ordinary characters “green” and “sitting on a wall.\n” are printed verbatim, and the conversion specifiers %d and %s insert the additional arguments at the appropriate locations. The type conversion character must match its associated argument type; in the example, the %d indicates an integer argument and the %s indicates a string argument.

There are different conversion characters for ints (d, i, o, x, c), unsigned ints (u), doubles (f, e, g), strings (s), and pointers (p). Details of these may be found in any C reference text.

To print a % character, the conversion specification %% is used. Between the % and the type conversion character there may exist a number of optional fields.

These control the formatting of the converted argument. Consider, for example, the conversion specifier %-#012.4hd

1.2           Formatted Input: scanf()

The scanf() function is the input analog of printf(), providing many of the same conversion specifications in the opposite direction (although there are differences, so be wary).

It obtains data from standard input, which is typically the keyboard. The general interface for scanf() is

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

This is identical to printf() in form, with a format string and a variable argument list, but an important difference is that the arguments for scanf() must be pointer types. This allows the input data to be stored at the address designated by the pointer using pass-by-reference semantics.

For example,

double fval;

scanf("%lf", fval); /* Wrong */

scanf("%lf", &fval); /* Correct, store input in fval. */

scanf() reads characters from standard input and interprets them according to the format string specification.

It stops when it exhausts the format string, or when some input fails to match a conversion specification. Its return value is the number of values successfully assigned in its variable-length argument list.

If a conflict occurs between the conversion specification and the actual input, the character causing the conflict is left unread and is processed by the next standard input operation.

The mechanics of the format string and its conversion specifications are even more complicated for scanf() than for printf(), and there are many details and caveats that will not be discussed here.

Most of the conversion characters for printf()—d, i, o, x, c, u, f, e, g, s, p, etc—have similar meanings for scanf(), but there are certain differences, some subtle.

Thus, one should not use the documentation for one as a guide for the other. Some of these differences are as follows.

•         Where printf() has four optional fields, scanf() has only two. It has the width and size modifier fields but not the flags and precision fields.

•         For printf() the width field specifies a minimum reserve of space (i.e., padding), while for scanf() it defines a maximum limit on the number of characters to be read.

•         An asterisk character (*) may be used in place of the width field for both printf() and scanf(), but with different meanings. For printf() it allows the width field to be determined by an additional argument, but for scanf() it suppresses assignment of an input value to its argument.

•         The conversion character [ is not valid for printf(), but for scanf() it permits a scanset of characters to be specified, which allows scanf() to control exactly the characters it reads in.

•         The size modifier field is typically neglected for printf(), but is vital for scanf(). For example, to read a float, one uses the conversion specifier %f. To read a double, the size modifier l (for long) must appear, %lf.

The scanf() format string consists of conversion specifiers, ordinary characters, and white-space. For example, the following statement is used to read a date of the form dd/mm/yy.

int day, month, year;

scanf("%d/%d/%d", &day, &month, &year);

In general scanf() ignores white-space characters in its format string, and skips over white-space in stdin as it looks for input values. Exceptions to this rule arise with the %c and %[ conversion specifiers, which do not skip white-space. For example, if the user types in “one two” for each of the statements below, they will obtain different results.

char s[10], c;

scanf("%s%c", s, &c); /* s = "one", c = ’ ’ */

scanf("%s %c", s, &c); /* s = "one", c = ’t’ */

In the first case, the %c reads in the next character after %s leaves off, which is a space. In the second, the white-space in the format string causes scanf() to consume any white-space after “one”, leaving the first non-space character (t) to be assigned to c.

While the many details of scanf() formatting complicates a complete understanding, its basic use is quite simple. Rarely does an input statement get more complicated than

short a;

double b;

char c[20];

scanf("%hd %lf %s", &a, &b, c);

 A few final warnings about scanf().

First, keep in mind that the arguments in its variable length argument list must be pointers; forgetting the & in front of non-pointer variables is a very common mistake.

Second, when there is a conflict between a conversion specification and the actual

input, the offending character is left unread. Thus, an expression like while (scanf("%d", &val) != EOF) is dangerous as it will loop forever if there is a conflict. Third, while scanf() is a good choice when the exact format of the input is known, other input techniques may be better suited if the format may vary. For example, the combination of fgets() and sscanf(), described in the next section, is a useful alternative if the input format is not precisely known. The fgets() function reads a line of characters into a buffer, and sscanf() extracts the data, and can pick out different parts using multiple passes if necessary.

1.3 String Formatting

The functions sprintf() and sscanf() perform essentially the same operations as printf() and scanf(), respectively, but, rather than interact with stdout or stdin, they operate on a character array argument. They present the following interfaces.

int sprintf(char *buf, const char *format, ...);

int sscanf(const char *buf, const char *format, ...);

The sprintf() function stores the resulting formatted string in buf and automatically appends this string with a terminating \0 character. It returns the number of characters stored (excluding \0). This function is very useful for a wide range of string manipulation operations. For example, the following code segment creates a format string at runtime, which prevents scanf() from overflowing its character buffer.

char buf[100], format[10];

sprintf(format, "%%%ds", sizeof(buf)-1); /* Create format string "%99s". */

scanf(format, buf); /* Get string from stdin. */

The input string is thus limited to not more than 99 characters plus 1 for the terminating \0. sscanf() extracts values from the string buf according to the format string, and stores the results in the additional argument list. It behaves just like scanf() with buf replacing stdin as the source of input characters. An attempt to read beyond the end of string buf for sscanf() is equivalent to reaching the end-of-file for scanf(). The sscanf() function is often used in conjunction with a line input function, such as fgets(), as in the following example.

char buf[100];

double dval;

fgets(buf, sizeof(buf), stdin); /* Get a line of input, store in buf. */

sscanf(buf, "%lf", &dval); /* Extract a double from buf. */

2.   File IO

The C language is closely tied to the UNIX operating system; they were initially developed in parallel, and UNIX was implemented in C. Thus, much of the standard C library is modelled on UNIX facilities, and in particular the way it performs input and output by reading or writing to files.

2.1 Opening and Closing Files

A file is referred to by a FILE pointer, where FILE is a structure declaration defined with a typedef in header stdio.h. This file pointer “points to a structure that contains information about the file, such as the location of a buffer, the current character position in the buffer, whether the file is being read or written, and whether errors or end-of-file have occurred”. All these implementation details are hidden from users of the standard library via the FILE type-name and the associated library functions.

è A file is opened by the function fopen(), which has the interface

FILE *fopen(const char *name, const char *mode);

The first argument, name, is a character string containing the name of the file. The second is a mode string, which determines how the file may be used.

There are three basic modes:

read "r", write "w" and append "a".

The first opens an existing file for reading, and fails if the file does not exist.

The other two open a file for writing, and create a new file if it does not already exist.

Opening an existing file in "w" mode, first clears the file of its existing data (i.e., overwrites the existing file).

Opening in "a" mode preserves the existing data and adds new data to the end of the file.

è Each of these modes may include an additional “update” specification signified by a + character (i.e., "r+", "w+", "a+"), which enables the file stream to be used for both input and output. This ability is most useful in conjunction with the random access file operations.

è The standard C library caters for this variation by permitting a file to be explicitly marked as binary with the addition of a b character to the file-open mode (e.g., "rb" opens a binary file for reading).

è If opening a file is successful, fopen() returns a valid FILE * pointer. If there is an error, it returns NULL (e.g., attempting to open a file for reading that does not exist, or attempting to open a file without appropriate permissions). As with other functions that return pointers to limited resources, such as the dynamic memory allocation functions, it is prudent to always check the return value for NULL.

è To close a file, the file pointer is passed to fclose(), which has the interface

int fclose(FILE *fp);

è This function breaks the connection with the file and frees the file pointer. It is good practice to free file pointers when a file is no longer needed as most operating systems have a limit on the number of files that a program may have open simultaneously. However, fclose() is called automatically for each open file when a program terminates.

2.2           Standard IO

When a program begins execution, there are three text streams predefined and open. These are

standard input (stdin)

standard output (stdout) and

standard error (stderr).

The first two signify “normal” input and output, and for most interactive environments are directed to the keyboard and screen, respectively. Their input and output streams are usually buffered, which means that characters are accumulated in a queue and sent in packets, minimising expensive system calls.

Buffering may be controlled by the standard function setbuf(). The stderr stream is reserved for sending error messages. Like stdout it is typically directed to the screen, but its output is unbuffered.

2.3           Sequential File Operations

Once a file is opened, operations on the file—reading or writing—usually negotiate the file in a sequential manner, from the beginning to the end. The standard library provides a number of different operations for sequential IO.

The simplest functions process a file one character at a time. To write a character there are the functions

int fputc(int c, FILE *fp);

int putc(int c, FILE *fp);

int putchar(int c);

where calling putchar(c) is equivalent to calling putc(c, stdout). The functions putc() and fputc() are identical, but putc() is typically implemented as a macro for efficiency. These functions return the character that was written, or EOF if there was an error (e.g., the hard disk was full).

To read a character, there are the functions

int fgetc(FILE *fp);

int getc(FILE *fp);

int getchar(void);

which are analogous to the character output functions. Calling getchar() is equivalent to calling getc(stdin), and getc() is usually a macro implementation of fgetc(). These functions return the next character in the character stream unless either the end-of-file is reached or an error occurs.

In these anomalous cases, they return EOF. It is possible to push a character c back onto an input stream using the function

int ungetc(int c, FILE *fp);

The pushed back character will be read by the next call to getc() (or getchar() or fscanf(), etc) on that stream.

Formatted IO can be performed on files using the functions

int fprintf(FILE *fp, const char *format, ...);

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

These functions are generalisations of printf() and scanf(), which are equivalent to the calls

fprintf(stdout, format, ...) and

fscanf(stdin, format, ...), respectively.

Characters can be read from a file a line at a time using the function

char *fgets(char *buf, int max, FILE *fp);

which reads at most max-1 characters from the file pointed to by fp and stores the resulting string in buf. It automatically appends a \0 character to the end of the string. The function returns when it encounters a \n character (i.e., a newline), or reaches the end-of-file, or has read the maximum number of characters. It returns a pointer to buf if successful, and NULL for end-of-file or if there was an error.

Character strings may be written to a file using the function

int fputs(const char *str, FILE *fp);

which returns a non-negative value if successful and EOF if there was an error. Note, the string need not contain a \n character, and fputs() will not append one, so strings may be written to the same line with successive calls.

For reading and writing binary files, a pair of functions are provided that enable objects to be passed to and from files directly without first converting them to a character string. These functions are

size_t fread(void *ptr, size_t size, size_t nobj, FILE *fp);

size_t fwrite(const void *ptr, size_t size, size_t nobj, FILE *fp);

and they permit objects of any type to be read or written, including arrays and structures. For example, if a structure called Astruct were defined, then an array of such structures could be written to file as follows.

struct Astruct mystruct[10];

fwrite(&mystruct, sizeof(Astruct), 10, fp);

2.4 Random Access File Operations

The previous file IO functions progress through a file sequentially. The standard library also provides a means to move back and forth within a file to any specified location. These file positioning functions are

long ftell(FILE *fp);

int fseek(FILE *fp, long offset, int from);

void rewind(FILE *fp);

The first, ftell(), returns the current position in the file stream. For binary files this value is the number of characters preceding the current position.

For text files the value is implementation defined. In both cases the value is in a form suitable for the second argument of fseek(), and the value 0L represents the beginning of the file.

The second function, fseek(), sets the file position to a location specified by its second argument. This parameter is an offset, which shifts the file position relative to a given reference location. The reference location is given by the third argument and may be one of three values as defined by the symbolic constants SEEK_SET, SEEK_CUR, and SEEK_END.

These specify the beginning of the file, the current file position, and the end of file, respectively. Having shifted the file position via fseek(), a subsequent read or write will proceed from this new position.

For binary files, fseek() may be used to move the file position to any chosen location. For text files, however, the set of valid operations is restricted to the following.

fseek(fp, 0L, SEEK_SET); /* Move to beginning of file. */

fseek(fp, 0L, SEEK_CUR); /* Move to current location (no effect). */

fseek(fp, 0L, SEEK_END); /* Move to end of file. */

fseek(fp, pos, SEEK_SET); /* Move to pos. */

In the last case, the value pos must be a position returned by a previous call to ftell(). Binary files, on the other hand, permit more arbitrary use, such as

fseek(fp, -4L, SEEK_CUR); /* Move back 4 bytes. */

The program below shows an example of ftell() and fseek() to determine the length of a file in bytes. The file itself may be plain text, but it is opened as binary so that ftell() returns the number of characters to the end-of-file.

/* Compute the length of a file in bytes. From Snippets (ansiflen.c) */

long flength(char *fname)

{

long length = −1L;

FILE *fptr;

fptr = fopen(fname, "rb");

if (fptr != NULL) {

fseek(fptr, 0L, SEEK END);

length = ftell(fptr);

fclose(fptr);

}

return length;

}

The third function, rewind(), returns the position to the beginning of the file. Calling rewind(fp) is equivalent to the statement fseek(fp, 0L, SEEK_SET).

Two other file positioning functions are available in the standard library: fgetpos() and fsetpos(). These perform essentially the same tasks as ftell() and fseek(), respectively, but are able to handle files too large for their positions to be representable by a long integer.

3.   Command-Shell Redirection

Often programs are executed from a command-interpreter environment (also called a shell). Most operating systems possess such an interpreter. For example, Win32 has a DOS-shell and UNIX-like systems have various similar shell environments such as the C-shell, the Bourne-shell, the Korn-shell, etc. Most shells facilitate redirection of stdin and stdout using the commands < and >, respectively.

Redirection is not part of the C language, but an operating system service that supports the C inputoutput model.

#include <stdio.h>

/* Write stdin to stdout */

int main(void)

{

int c;

while ((c = getchar()) != EOF)

putchar(c);

}

Consider the example program above. It simply reads characters from stdin and forwards them to stdout. Normally this means the characters typed at the keyboard are echoed on the screen after the user hits the “enter” key. Assume the program executable is named “repeat”.

repeat

type some text 123

type some text 123

However, a file may be substituted for the keyboard by redirection.

repeat <infile.txt

display contents of infile.txt

Alternatively, a file may be substituted for the screen, or for both keyboard and screen as in the following example, which copies the contents of infile.txt to outfile.txt.

repeat <infile.txt >outfile.txt

Further redirection commands are >> and |. The former redirects stdout but, unlike >, appends the redirected output rather than overwriting the existing file contents. The latter is called a “pipe”, and it directs the stdout of one program to the stdin of another. For example, prog1 | prog2

prog1 executes first and its stdout is accumulated in a temporary buffer and, once the program has terminated, prog2 executes with this set of output as its stdin. The stderr stream is not redirected, and so will still print messages to the screen even if stdout is redirected.