C++ input output

CHAPTER 7: Input and Output

Input and output facilities are not part of the C language itself, so we have not emphasized them in our presentation thus far. Nonetheless, programs interact with their environment in much more complicated ways than those we have shown before. In this chapter we will describe the standard library, a set ,)f functions that provide input and output, string handling, storage manage­ment, mathematical routines, and a variety of other services for C programs. We will concentrate on input and output.

The ANSI standard defines these library functions precisely, so that they can exist in compatible form on any system where C exists. Programs that confine their system interactions to facilities provided by the standard library can be moved from one system to another without change.

The properties of library functions are specified in more than a dozen headers; we have already seen several of these, including <stdio.h>, <string.h>, and <ctype.h>. We will not present the entire library here, since we are more interested in writing C programs that use it. The library is described in detail in Appendix B.

7.1 Standard Input and Output

As we said in Chapter 1, the 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 is 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:

int getchar(void)

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, but 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

prog <infile

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. The function

int putchar(int)

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 if an error occurs. Again, output can usually be directed to a file with >filename: if prog uses putchar,

prog >outfile

will write the standard output to outfile instead.

If pipes are supported,

 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 appears in the order in which the calls were made.

Each source file that refers to an input/output library function must contain the line

#include <stdio.h>

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 system^,. 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:

#include <stdio.h>

#include <ctype.h>

main() /* lower: convert input to lower case */ {

int c;

while ((c = getchar()) 1= EOF) putchar(tolower(c)); return 0;

The function tolower is defined in <ctype.h>; it converts an upper case letter to lower case, and returns other characters untouched.  Regardless of how the <ctype.h> functions are implemented on a given machine, programs that use them are shielded from knowledge of the character set.

7.2   Formatted Output—Printf

The output function printf translates internal values to characters. We have used printf informally in previous chapters. The description here covers the typical uses but is not complete; for the full story, see Appendix B.

int printf( char *format, arg, , arg₁ , ... )

printf converts, formats, and prints its arguments on the standard output under control of the format. It returns the number of characters printed.

The format string contains two types of objects: ordinary characters, which are copied to the output stream, and conversion specifications, each of which can ,us conversion and printing of the next successive argument to printf. Each conversion specification begins with a % and ends with a conversion character.  Between the % and the conversion character there may be, in order:

·  A minus sign, which specifies left adjustment of the converted argument.

·  A number that specifies the minimum field width. The converted argument will be hinted in a field at least this wide. If necessary it will be padded on the left (or right, if left adjustment is called for) to make up the field width.

·  A period, which separates the field width from the precision.

·  A number, the precision, that specifies the maximum number of characters to be printed from a string, or the number of digits after the decimal point of a floating-point value, or the minimum number of digits for an integer.

·  • An h if the integer is to be printed as a short:, or l (letter ell) if as a long

·  Conversion characters are shown in Table 7-I. If the character after the % is not a conversion specification, the behavior is undefined.

Table 7-l. Basic Printf Conversions

CHARACTER	ARGUMENT TYPE;	PRINTED AS
d.i	int;	decimal number.
o	int;	unsigned octal number (without a leading zero).
x,X	int;	unsigned hexadecimal number (without a leading 0x 0X), using abcdef or ABCDEF for 10, ..., 15.
u	int;	unsigned decimal number.
c	int; .	single character
s	char *;	print characters from the string until a '\0' or the number of characters given by the precision.
f	double;	[-]m.dddddd, where the number of d's is given by the precision (default 6).
e,E	double;	[-]m.dddddde±xx or [-]m.ddddddE±xx,where the number of d's is given by the precision (default 6).
g,G	double;	use %e or %E if the exponent is less than -4 or greater than or equal to the precision; otherwise use%f. Trailing zeros and a trailing decimal point are not printed.
p	void *;	pointer (implementation-dependent representation).
%	no argument isconverted;	print a %.

A width or precision may be specified as *, in which case the value is computed by converting the next argument (which must be an int). For example to print at most max characters from a string s,

printf("%.*s", max, s);

Most of the format conversions have been illustrated in earlier chapters.  One exception is precision as it relates to strings. The following table shows the effect of a variety of specifications in printing “hellos, world” (12 characters).  We have put colons around each field so you can see its extent.

:%s:          :hello, world:

:%10s:        :hello, world:

:%.10s:      :hello, wor:

:%-10s:      :hello, world:

:%.15s:      :hello, world:

:%-15s:      :hello, world    ;

:%15.10s;    ;     hello, wor:

:%-15.10s:  :hello, wor      ;

A warning: printf uses its first argument to decide how many arguments follow, and what their types are;  it will get confused, and give wrong answers, if there are not enough arguments, or if they are of the wrong types.  You should also be aware of the difference between these two calls:

printf(s);	/* FAILS if s contains a % */
printf(“%s”,s);	/* Safe */

7.4 Formatted Input—Scant

The function scanf is the input analog of printf, providing many of the me conversion facilities in the opposite direction.

int scanf(char *format, ...)

scanf reads characters from the standard input, interprets them according to the specifications in format, and stores the results through the remaining arguments. The format argument is described below; the other arguments, each of which must be a pointer, indicate where the corresponding converted input should be stored. As with printf, this section is a summary of the most useful features, not an exhaustive list.

scanf stops when it exhausts its format string, or when some input fails to match the control specification. It returns as its value the number of successfully matched and assigned input items. This can be used to decide how many items were found. On end of file, EOF is returned; note that this is different ' from 0, which means that the next input character does not match the first specification in the format string. The next call toscanf resumes searching immediately after the last character already converted.

There is also a function sscanf that reads from a string instead of the :standard input:

int sscanf (char *string, char *format, arg1, arg₂,... )

It scans the string according to the format in format, and stores the resulting values through arg₁, arg₂, etc. These arguments must be pointers.  The format string usually contains conversion specifications, which are used to control conversion of input. The format string may contain:

·  Blanks or tabs, which are ignored.

·  Ordinary characters (not %), which are expected to match the next non-white space character of the input stream.

·  Conversion specifications, consisting of the character %, an optional assignment suppression character *, an optional number specifying a maximum field width, an optional h, 1, or L indicating the width of the target, and a conversion character.

A conversion specification directs the conversion of the next input field. Normally the result is placed in the variable pointed to by the corresponding argument. If assignment suppression is indicated by the * character, however, the input field is skipped; no assignment is made. An input field is defined as a string of non-white space characters; it extends either to the next white space character or until the field width, if specified, is exhausted. This implies that scanf will read across line boundaries to find its input, since newlines are white space. (White space characters are blank, tab, newline, carriage return, vertical tab, and formfeed.)

The conversion character indicates the interpretation of the input field. The corresponding argument must be a pointer, as required by the call-by-value semantics of C.

Table 7-2. Basic Scanf Conversions

CHARACTER	Input Format	Type
d	decimal integer.	int *
i	integer (may be in octal (leading 0), or hexadecimal (leading 0x or 0X)	int *
o	octal integer (with or without a leading zero).	int *
x	hexadecimal integer (without a leading 0x 0X)	int *
u	unsigned decimal integer.	unsigned int *
c	characters.  The next input characters (default 1) are placed at the indicated spot in memory.	char *
s	character string ( not quoted)	char * pointing to an array of characters large enough to hold all the characters read, plus a n added \0
e,f,g	Floating point number with optional sign, optional decimal point, and optional exponent	float *
%	no argument is converted;	print a %.

The conversion characters d, i, o, u, and x may be preceded by h to indicate that a pointer to short rather than int appears in the argument list, or by 1 (letter ell) to indicate that a pointer to long appears in the argument list... Similarly, the conversion characters e, f, and g may be preceded by l to indicate that a pointer to double rather than float is in the argument list.