Input & output

1
OBJECTIVES
In this chapter you will learn:
To use input and output streams.
To use all print formatting capabilities.
To use all input formatting capabilities.
To print with field widths and
precisions.
To use formatting flags in the printf
format control string.
To output literals and escape
sequences.
To format input using scanf.

2
Streams
All input and output is performed with streams,
which are sequences of bytes.
In input operations, the bytes flow from a device
(e.g., a keyboard, a disk drive, a network
connection) to main memory.
In output operations, bytes flow from main
memory to a device (e.g., a display screen, a
printer, a disk drive, a network connection, and
so on).
When program execution begins, three streams
are connected to the program automatically.
3
Formatting Output with printf
printf
◦ Precise output formatting
 Conversion specifications: flags, field widths, precisions,
etc.
◦ Can perform rounding, aligning columns, right/left
justification, inserting literal characters,
exponential format, hexadecimal format, and
fixed width and precision
Format
◦ printf( format-control-string, other-arguments );
◦ Format control string: describes output format
◦ Other-arguments: correspond to each conversion
specification in format-control-string
 Each specification begins with a percent sign(%), ends with
conversion specifier

4
Printing Integers
Integer
◦ Whole number (no decimal point):
25, 0, -9
◦ Positive, negative, or zero
◦ Only minus sign prints by default
(later we will change this)

5
Conversion specifier Description
d Display as a signed decimal integer.
i Display as a signed decimal integer. [Note: The i and d specifiers
are different when used with scanf.]
o Display as an unsigned octal integer.
u Display as an unsigned decimal integer.
x or X Display as an unsigned hexadecimal integer. X causes the digits
0-9 and the letters A-F to be displayed and x causes the digits
0-9 and a-f to be displayed.
h or l (letter l) Place before any integer conversion specifier to indicate that a
short or long integer is displayed, respectively. Letters h and l
are more precisely called length modifiers.

Integer conversion specifiers.

6
1 /* Fig 9.2: fig09_02.c */
2 /* Using the integer conversion specifiers */
3 #include <stdio.h>
4
d and i specify signed integers
5 int main( void )
6 {
7 printf( "%d\n", 455 );
8 printf( "%i\n", 455 ); /* i same as d in printf */
9 printf( "%d\n", +455 );
10 printf( "%d\n", -455 ); h specifies a short number
11 printf( "%hd\n", 32000 );
12 printf( "%ld\n", 2000000000L ); /* L suffix makes literal a long */ l specifies a long number
13 printf( "%o\n", 455 );
o specifies an octal integer
14 printf( "%u\n", 455 );
15 printf( "%u\n", -455 );
16 printf( "%x\n", 455 );
17 printf( "%X\n", 455 );
18 u specifies an unsigned integer x and X specify hexadecimal integers
19 return 0; /* indicates successful termination */
20
21 } /* end main */

455
455
455
-455
32000
2000000000
707
455
4294966841
1c7
1C7

7
Printing Floating-Point
Numbers
Floating Point Numbers
◦ Have a decimal point (33.5)
◦ Exponential notation (computer's
version of scientific notation)
 150.3 is 1.503 x 10² in scientific
 150.3 is 1.503E+02 in exponential

8
Conversion specifier Description
e or E Display a floating-point value in exponential notation.
f Display floating-point values in fixed-point notation.
g or G Display a floating-point value in either the floating-point
form f or the exponential form e (or E), based on the
magnitude of the value.
L Place before any floating-point conversion specifier to
indicate that a long double floating-point value is
displayed.

Floating-point conversion specifiers.

9
1 /* Fig 9.4: fig09_04.c */
2 /* Printing floating-point numbers with
3 floating-point conversion specifiers */
4
5 #include <stdio.h>
6
7 int main( void )
8 {
9 printf( "%e\n", 1234567.89 );
10 printf( "%e\n", +1234567.89 ); e and E specify exponential notation
11 printf( "%e\n", -1234567.89 );
12 printf( "%E\n", 1234567.89 );
13 printf( "%f\n", 1234567.89 ); f specifies fixed-point notation
14 printf( "%g\n", 1234567.89 );
15 printf( "%G\n", 1234567.89 );
16 g and G specify either exponential or fixed-point
17 return 0; /* indicates successful termination */ notation depending on the number’s size
18
19 } /* end main */

1.234568e+006
1.234568e+006
-1.234568e+006
1.234568E+006
1234567.890000
1.23457e+006
1.23457E+006

10
 Printing Strings and Characters
c
◦ Prints char argument
◦ Cannot be used to print the first character of a
string
s
◦ Requires a pointer to char as an argument
◦ Prints characters until NULL ('\0') encountered
◦ Cannot print a char argument
Remember
◦ Single quotes for character constants ( 'z')
◦ Double quotes for strings "z" (which actually
contains two characters, 'z' and '\0')

11
1 /* Fig 9.5: fig09_05c */
2 /* Printing strings and characters */
3 #include <stdio.h>
4
5 int main( void )
6 {
7 char character = 'A'; /* initialize char */
8 char string[] = "This is a string"; /* initialize char array */
9 const char *stringPtr = "This is also a string"; /* char pointer */
10
11 printf( "%c\n", character ); c specifies a character will be printed
12 printf( "%s\n", "This is a string" );
13 printf( "%s\n", string );
14 printf( "%s\n", stringPtr ); s specifies a string will be printed
15
16 return 0; /* indicates successful termination */
17
18 } /* end main */

A
This is a string
This is a string
This is also a string

12
Printing with Field Widths and
Precision
Field width
◦ Size of field in which data is printed
◦ If width larger than data, default
right justified
 If field width too small, increases to fit
data
 Minus sign uses one character position in
field
◦ Integer width inserted between % and
conversion specifier
◦ %4d – field width of 4
13
1 /* Fig 9.8: fig09_08.c */
2 /* Printing integers right-justified */
3 #include <stdio.h>
4
5 int main( void )
6 {
7 printf( "%4d\n", 1 );
8 printf( "%4d\n", 12 );
A field width of 4 will make C attempt to
9 printf( "%4d\n", 123 ); print the number in a 4-character space
10 printf( "%4d\n", 1234 );
11 printf( "%4d\n\n", 12345 );
12
13 printf( "%4d\n", -1 );
14
Note that C considers the minus sign a character
printf( "%4d\n", -12 );
15 printf( "%4d\n", -123 );
16 printf( "%4d\n", -1234 );
17 printf( "%4d\n", -12345 );
18
19 return 0; /* indicates successful termination */
20
21 } /* end main */

1
12
123
1234
12345

-1
-12
-123
-1234
-12345
14
2 /* Using precision while printing integers,
3 floating-point numbers, and strings */
4 #include <stdio.h>
5
6 int main( void )
7 {
8 int i = 873; /* initialize int i */
9 double f = 123.94536; /* initialize double f */
10 char s[] = "Happy Birthday"; /* initialize char array s */
11
12 printf( "Using precision for integers\n" );
13 printf( "\t%.4d\n\t%.9d\n\n", i, i );
Precision for integers specifies the minimum
14
15 printf( "Using precision for floating-point
number of characters to be printed
numbers\n" );
16 printf( "\t%.3f\n\t%.3e\n\t%.3g\n\n", f, f, f );
17 Precision for the g specifier controls the
18 printf( "Using precision for strings\n" ); maximum number of significant digits printed
19 printf( "\t%.11s\n", s );
20 Precision for strings specifies the maximum
21 return 0; /* indicates successful termination */ number of characters to be printed
22
23 } /*Precision
end main for
*/ f and e specifiers controls the
Using numberfor
precision of digits after the decimal point
integers
0873
000000873

Using precision for floating-point numbers

123.945
1.239e+002
124

Using precision for strings

Happy Birth 15
Using Flags in the printf
Format Control String
Flags
◦ Supplement formatting capabilities
◦ Place flag immediately to the right of
percent sign
◦ Several flags may be combined

16
Flag Description
- (minus sign) Left justify the output within the specified field.
+ (plus sign) Display a plus sign preceding positive values and a minus sign
preceding negative values.
space Print a space before a positive value not printed with the + flag.
# Prefix 0 to the output value when used with the octal conversion
specifier o.
Prefix 0x or 0X to the output value when used with the hexadecimal
conversion specifiers x or X.
Force a decimal point for a floating-point number printed with e, E, f,
g or G that does not contain a fractional part. (Normally the decimal
point is printed only if a digit follows it.) For g and G specifiers,
trailing zeros are not eliminated.
0 (zero) Pad a field with leading zeros.

Format control string flags.

17
1 /* Fig 9.11: fig09_11.c */
2 /* Right justifying and left justifying values */
3 #include <stdio.h>
4
5 int main( void )
6 {
7 printf( "%10s%10d%10c%10f\n\n", "hello", 7, 'a', 1.23 );
8 printf( "%-10s%-10d%-10c%-10f\n", "hello", 7, 'a', 1.23 );
9
10 return 0; /* indicates successful termination */ - flag left justifies characters in a field
11
12 } /* end main */

hello 7 a 1.230000

hello 7 a 1.230000

18
1 /* Fig 9.12: fig09_12.c */
2 /* Printing numbers with and without the + flag */
3 #include <stdio.h>
4
5 int main( void )
6 {
7 printf( "%d\n%d\n", 786, -786 );
8 printf( "%+d\n%+d\n", 786, -786 );
+ flag forces a plus sign on positive numbers
9
10 return 0; /* indicates successful termination */
11
12 } /* end main */

786
-786
+786
-786

19
1 /* Fig 9.13: fig09_13.c */
2 /* Printing a space before signed values
3 not preceded by + or - */
4 #include <stdio.h>
5
6 int main( void )
7 {
8 printf( "% d\n% d\n", 547, -547 );
Space flag forces a space on positive numbers
9
10 return 0; /* indicates successful termination */
11
12 } /* end main */

547
-547

20
1 /* Fig 9.14: fig09_14.c */
2 /* Using the # flag with conversion specifiers
3 o, x, X and any floating-point specifier */
4 #include <stdio.h>
5
6 int main( void )
7 {
8 int c = 1427; /* initialize c */
9 double p = 1427.0; /* initialize p */
10
11
# flag prefixes a 0 before octal integers
printf( "%#o\n", c );
12 printf( "%#x\n", c );
13 printf( "%#X\n", c ); # flag prefixes a 0x before hexadecimal integers
14 printf( "\n%g\n", p );
15 printf( "%#g\n", p ); # flag forces a decimal point on a value
16
printed with g
17 return 0; /* indicates successful termination */
18
19 } /* end main */

02623
0x593
0X593

1427
1427.00

21
1 /* Fig 9.15: fig09_15.c */
2 /* Printing with the 0( zero ) flag fills in leading zeros */
3 #include <stdio.h>
4 + flag and 0 flag print 452 in
5 int main( void ) 9-space field with a + sign and
6 { leading zeros
7 printf( "%+09d\n", 452 );
8 printf( "%09d\n", 452 ); 0 flag fills empty spaces with zeros
9
10 return 0; /* indicates successful termination */
11
12 } /* end main */

+00000452
000000452

22
Printing Literals and Escape
Sequences
Printing Literals
◦ Most characters can be printed
◦ Certain "problem" characters, such
as the quotation mark "
◦ Must be represented by escape
sequences
 Represented by a backslash \ followed by
an escape character

23
Escape sequence Description
\' (single quote) Output the single quote (') character.
\" (double quote) Output the double quote (") character.
\? (question mark) Output the question mark (?) character.
\\ (backslash) Output the backslash (\) character.
\a (alert or bell) Cause an audible (bell) or visual alert.
\b (backspace) Move the cursor back one position on the current line.
\f (new page or form feed) Move the cursor to the start of the next logical page.
\n (newline) Move the cursor to the beginning of the next line.
\r (carriage return) Move the cursor to the beginning of the current line.
\t (horizontal tab) Move the cursor to the next horizontal tab position.
\v (vertical tab) Move the cursor to the next vertical tab position.

Escape sequences.
24
Formatting Input with
scanf
scanf
◦ Input can be formatted much like
output can
◦ scanf conversion specifiers are
slightly different from those used
with printf

25
 Conversion specifier Description
Integers
d Read an optionally signed decimal integer. The corresponding
argument is a pointer to an int.
i Read an optionally signed decimal, octal or hexadecimal
integer. The corresponding argument is a pointer to an int.
o Read an octal integer. The corresponding argument is a pointer
to an unsigned int.
u Read an unsigned decimal integer. The corresponding
argument is a pointer to an unsigned int.
x or X Read a hexadecimal integer. The corresponding argument is a
pointer to an unsigned int.
h or l Place before any of the integer conversion specifiers to
indicate that a short or long integer is to be input.

Conversion specifiers for scanf. (Part 1 of 3.)

26
 Conversion specifier Description
Floating-point numbers
e, E, f, g or G Read a floating-point value. The corresponding argument is a
pointer to a floating-point variable.
l or L Place before any of the floating-point conversion specifiers to
indicate that a double or long double value is to be
input. The corresponding argument is a pointer to a double
or long double variable.
Characters and strings

c Read a character. The corresponding argument is a pointer to

a char; no null ('\0') is added.
s Read a string. The corresponding argument is a pointer to an
array of type char that is large enough to hold the string and
a terminating null ('\0') character—which is automatically
added.

Conversion specifiers for scanf. (Part 2 of 3.)

27
 Conversion specifier Description
Scan set
[scan characters] Scan a string for a set of characters that are stored in an array.
Miscellaneous

p Read an address of the same form produced when an address

is output with %p in a printf statement.
n Store the number of characters input so far in this call to
scanf. The corresponding argument is a pointer to an int.
% Skip a percent sign (%) in the input.

Conversion specifiers for scanf. (Part 3 of 3.)

28
1 /* Fig 9.18: fig09_18.c */
2 /* Reading integers */
3 #include <stdio.h>
4
5 int main( void )
6 { d specifies a decimal integer will be input
7 int a;
8 int b; i specifies an integer will be input
9 int c;
10 int d; o specifies an octal integer will be input
11 int e;
12 int f;
u specifies an unsigned decimal integer will be input
13 int g;
x specifies a hexadecimal integer will be input
14
15 printf( "Enter seven integers: " );
16 scanf( "%d%i%i%i%o%u%x", &a, &b, &c, &d, &e, &f, &g );
17
18 printf( "The input displayed as decimal integers is:\n" );
19 printf( "%d %d %d %d %d %d %d\n", a, b, c, d, e, f, g );
20
21 return 0; /* indicates successful termination */
22
23 } /* end main */

Enter seven integers: -70 -70 070 0x70 70 70 70

The input displayed as decimal integers is:
-70 -70 56 112 56 70 112

29
1 /* Fig 9.19: fig09_19.c */
2 /* Reading floating-point numbers */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 { e, f, and g specify a floating-point number will be input
8 double a;
9 double b;
l specifies a double or long double will be input
10 double c;
11
12 printf( "Enter three floating-point numbers: \n" );
13 scanf( "%le%lf%lg", &a, &b, &c );
14
15 printf( "Here are the numbers entered in plain\n" );
16 printf( "floating-point notation:\n" );
17 printf( "%f\n%f\n%f\n", a, b, c );
18
19 return 0; /* indicates successful termination */
20
21 } /* end main */

Enter three floating-point numbers:

1.27987 1.27987e+03 3.38476e-06
Here are the numbers entered in plain
floating-point notation:
1.279870
1279.870000
0.000003

30
1 /* Fig 9.20: fig09_20.c */
2 /* Reading characters and strings */
3 #include <stdio.h>
4
5 int main( void )
6 { c specifies a character will be input
7 char x;
8 char y[ 9 ]; s specifies a string will be input
9
10 printf( "Enter a string: " );
11 scanf( "%c%s", &x, y );
12
13 printf( "The input was:\n" );
14 printf( "the character \"%c\" ", x );
15 printf( "and the string \"%s\"\n", y );
16
17 return 0; /* indicates successful termination */
18
19 } /* end main */

Enter a string: Sunday

The input was:
the character "S" and the string "unday"

31
1 /* Fig 9.23: fig09_23.c */
2 /* inputting data with a field width */
3 #include <stdio.h>
4
5 int main( void )
6 { A field width of 2 tells C to only read
7 int x; the first 2 characters of that input
8 int y;
9
10 printf( "Enter a six digit integer: " );
11 scanf( "%2d%d", &x, &y );
12
13 printf( "The integers input were %d and %d\n", x, y );
14
15 return 0; /* indicates successful termination */
16
17 } /* end main */

Enter a six digit integer: 123456

The integers input were 12 and 3456

32
1 /* Fig 9.24: fig09_24.c */
2 /* Reading and discarding characters from the input stream */
3 #include <stdio.h>
4
5 int main( void )
6 {
7 int month1;
8 int day1; * is a wildcard—scanf will disregard anything
9 int year1; between the two inputs on either side of it
10 int month2;
11 int day2;
12 int year2;
13
14 printf( "Enter a date in the form mm-dd-yyyy: " );
15 scanf( "%d%*c%d%*c%d", &month1, &day1, &year1 );
16
17 printf( "month = %d day = %d year = %d\n\n", month1, day1, year1 );
18
19 printf( "Enter a date in the form mm/dd/yyyy: " );
20 scanf( "%d%*c%d%*c%d", &month2, &day2, &year2 );
21
22 printf( "month = %d day = %d year = %d\n", month2, day2, year2 );
23
24 return 0; /* indicates successful termination */
25
26 } /* end main */

Enter a date in the form mm-dd-yyyy: 11-18-2003

month = 11 day = 18 year = 2003

Enter a date in the form mm/dd/yyyy: 11/18/2003

month = 11 day = 18 year = 2003

33
References

Problem Solving using C, Uckan, Yuksel, Mc

Graw Hill, 1999.

C How to Program, Deitel&Deitel, Prentice-Hall,

5th Edition, 2007.

34
Q&A
Any Question?

35
 Thank You
#End of Session#

36