TMC 1414

INTRODUCTION
TO
PROGRAMMING

Lecture 06: Formatted Input/Output

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.
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.
FORMATTING OUTPUT WITH
PRINTF
 printf
 Precise output formatting
 Conversion specifications: flags, field widths, precisions, literal characters.
 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
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)
 https://www.tutorialspoint.com/cprogramming/c_data_types.htm
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
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 );
14 printf( "%u\n", 455 );
o specifies an octal integer
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
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
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
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
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')
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
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
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 print the
9 printf( "%4d\n", 123 ); number in a 4-character space
10 printf( "%4d\n", 1234 );
11 printf( "%4d\n\n", 12345 );
12
13 printf( "%4d\n", -1 );
14 printf( "%4d\n", -12 );
Note that C considers the minus sign a character
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
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 number of characters to be printed
15 printf( "Using precision for floating-point 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 maximum
18 printf( "Using precision for strings\n" ); 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
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
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
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
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
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
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 printf( "%#o\n", c );
# flag prefixes a 0 before octal integers
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
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
FORMATTING INPUT WITH
SCANF
 scanf
 Input can be formatted much like output
 scanf conversion specifiers are slightly different from those used with
printf
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.
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
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
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
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
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"
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
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 between
9 int year1; 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
THANK
YOU