Lecture 2:

Character Input/Output in C

Professor Jennifer Rexford

COS 217

http://www.cs.princeton.edu/courses/archive/spring08/cos217/
1
Overview of Today’s Lecture
• Goals of the lecture
 Important C constructs
– Program flow (if/else, loops, and switch)
– Character input/output (getchar and putchar)
 Deterministic finite automata (i.e., state machine)
 Expectations for programming assignments

• C programming examples
 Echo the input directly to the output
 Put all lower-case letters in upper case
 Put the first letter of each word in upper case

• Glossing over some details related to “pointers”

 … which will be covered in the next lecture 2
Echo Input Directly to Output
• Including the Standard Input/Output (stdio) library
 Makes names of functions, variables, and macros available
 #include <stdio.h>

• Defining procedure main()

 Starting point of the program, a standard boilerplate
 int main(void)
 int main(int argc, char **argv)
 Hand-waving: argc and argv are for input arguments

• Read a single character

 Returns a single character from the text stream “standard in” (stdin)
 c = getchar();

• Write a single character

 Writes a single character to “standard out” (stdout)
 putchar(c); 3
Putting it All Together
#include <stdio.h>

int main(void) {
int c;

c = getchar();
Why an “int”?
putchar(c);

return 0;
}
Why a return value?

4
Why is the Character an “int”
• Meaning of a data type
 Determines the size of a variable
 … and how it is interpreted and manipulated
• Difference between char and int
 char: character, a single byte (256 different values)
 int: integer, machine-dependent (e.g., -32,768 to
32,767)

• One byte is just not big enough

 Need to be able to store any character
 … plus, special value like End-Of-File (typically “-1”)
 We’ll see an example with EOF in a few slides
5
Read and Write Ten Characters
• Loop to repeat a set of lines (e.g., for loop)
 Three arguments: initialization, condition, and re-initialization
 E.g., start at 0, test for less than 10, and increment per iteration

#include <stdio.h>
int main(void) {
int c, i;

for (i=0; i<10; i++) {

c = getchar();
putchar(c);
}
return 0;
} 6
Read and Write Forever
• Infinite for loop
 Simply leave the arguments blank
 E.g., for ( ; ; )

#include <stdio.h>
int main(void) {
int c;

for ( ; ; ) {
c = getchar();
putchar(c);
}
return 0;
} 7
Read and Write Till End-Of-File
• Test for end-of-file (EOF)
 EOF is a special global constant, defined in stdio
 The break statement jumps out of the current scope before the loop
#include <stdio.h>
int main(void) {
int c; do some stuff
for ( ; ; ) {
c = getchar(); done yet?
if (c == EOF)
break;
do more stuff
putchar(c);
}
return 0;
} after the loop 8
Many Ways to Say the Same Thing
for (c=getchar(); c!=EOF; c=getchar())
putchar(c);

while ((c=getchar())!=EOF) Very typical idiom in C,

but messy side-effects in
putchar(c); loop test
for (;;) { c = getchar();
c = getchar();
while (c!=EOF) {
if (c == EOF)
break; putchar(c);
putchar(c); c = getchar();
} } 9
Review of Example #1
• Character I/O
 Including stdio.h
 Functions getchar() and putchar()
 Representation of a character as an integer
 Predefined constant EOF

• Program control flow

 The for loop and while loop
 The break statement
 The return statement

• Assignment and comparison

 Assignment: “=”
 Increment: “i++”
 Comparing for equality “==”
 Comparing for inequality “!=”
10
Example #2: Convert Upper Case
• Problem: write a program to convert a file to all upper-case
(leave nonalphabetic characters alone)
• Program design:
repeat
read a character
if it’s lower-case, convert to upper-case
write the character
until end-of-file

11
ASCII
American Standard Code for Information Interchange
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
16 DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
32 SP ! " # $ % & ' ( ) * + , - . /
48 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 @ A B C D E F G H I J K L M N O
80 P Q R S T U V W X Y Z [ \ ] ^ _
96 ` a b c d e f g h i j k l m n o
112 p q r s t u v w x y z { | } ~ DEL

Lower case: 97-122 and upper case: 65-90

E.g., ‘a’ is 97 and ‘A’ is 65 (i.e., 32 apart)
12
Implementation in C
#include <stdio.h>
int main(void) {
int c;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
if ((c >= 97) && (c < 123))
c -= 32;
putchar(c);
}
return 0;
}
13
That’s a B-minus
• Programming well means programs that are
 Clean
 Readable
 Maintainable

• It’s not enough that your program works!

 We take this seriously in COS 217.

14
Avoid Mysterious Numbers
#include <stdio.h>
int main(void) {
int c; Correct, but ugly to
for ( ; ; ) { have all these hard-
c = getchar(); wired constants in the
program.
if (c == EOF) break;
if ((c >= 97) && (c < 123))
c -= 32;
putchar(c);
}
return 0;
} 15
Improvement: Character Literals
#include <stdio.h>
int main(void) {
int c;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
if ((c >= ’a’) && (c <= ’z’))
c += ’A’ - ’a’;
putchar(c);
}
return 0;
} 16
Improvement: Existing Libraries
Standard C Library Functions ctype(3C)

NAME
ctype, isdigit, isxdigit, islower, isupper, isalpha, isalnum, isspace, iscntrl, ispunct, isprint,
isgraph, isascii - character handling

SYNOPSIS
#include <ctype.h> DESCRIPTION
int isalpha(int c);
These macros classify character-
int isupper(int c); coded integer values. Each is a
int islower(int c); predicate returning non-zero for true, 0
int isdigit(int c); for false...
int isalnum(int c); The toupper() function has as a
int isspace(int c); domain a type int, the value of which is
int ispunct(int c); representable as an unsigned char or
the value of EOF.... If the argument of
int isprint(int c);
toupper() represents a lower-case
int isgraph(int c); letter ... the result is the corresponding
int iscntrl(int c); upper-case letter. All other arguments
int toupper(int c); in the domain are returned unchanged.
int tolower(int c); 17
Using the ctype Library
#include <stdio.h>
#include <ctype.h>
int main(void) {
int c;
for ( ; ; ) {
c = getchar();
if (c == EOF) break; Returns 1 (true) if c is
between ‘a’ and ‘z’
if (islower(c))
c = toupper(c);
putchar(c);
}
return 0;
} 18
Compiling and Running
% ls
get-upper.c
% gcc get-upper.c
% ls
a.out get-upper.c
% a.out
We’ll be on time today!
WE’LL BE ON TIME TODAY!
^D
% 19
Run the Code on Itself
% a.out < get-upper.c
#INCLUDE <STDIO.H>
#INCLUDE <CTYPE.H>
INT MAIN(VOID) {
INT C;
FOR ( ; ; ) {
C = GETCHAR();
IF (C == EOF) BREAK;
IF (ISLOWER(C))
C = TOUPPER(C);
PUTCHAR(C);
}
RETURN 0;
}

20
Output Redirection
% a.out < get-upper.c > test.c
% gcc test.c
test.c:1:2: invalid preprocessing directive #INCLUDE
test.c:2:2: invalid preprocessing directive #INCLUDE
test.c:3: syntax error before "MAIN"
etc...

21
Review of Example #2
• Representing characters
 ASCII character set
 Character constants (e.g., ‘A’ or ‘a’)

• Manipulating characters
 Arithmetic on characters
 Functions like islower() and toupper()

• Compiling and running C code

 Compile to generate a.out
 Invoke a.out to run program
 Can redirect stdin and/or stdout

22
Example #3: Capitalize First Letter
• Capitalize the first letter of each word
 “cos 217 rocks”  “Cos 217 Rocks”

• Sequence through the string, one letter at a time

 Print either the character, or the upper-case version

• Challenge: need to remember where you are

 Capitalize “c” in “cos”, but not “o” in “cos” or “c” in “rocks”

• Solution: keep some extra information around

 Whether you’ve encountered the first letter in the word

23
Deterministic Finite Automaton
Deterministic Finite Automaton (DFA)

not-letter letter
letter

1 2

not-letter

State #1: before the 1st letter of a word

State #2: after the 1st letter of a word
Capitalize on transition from state 1 to 2

“cos 217 rocks”  “Cos 217 Rocks” 24

Implementation Skeleton
#include <stdio.h>
#include <ctype.h>
int main (void) {
int c;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
<process one character>
}
return 0;
} 25
 not-letter letter
letter
Implementation 1 2
not-letter
<process one character> =
switch (state) { if (isalpha(c)) {
putchar(toupper(c));
case 1: state = 2;
<state 1 action> }
else putchar(c);
break;
case 2: if (!isalpha(c))
<state 2 action> state = 1;
putchar(c);
break;
default:
<this should never happen>
}
26
Complete Implementation
#include <stdio.h>
#include <ctype.h>
int main(void) {
int c; int state=1;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
switch (state) {
case 1:
if (isalpha(c)) {
putchar(toupper(c));
state = 2;
} else putchar(c);
break;
case 2:
if (!isalpha(c)) state = 1;
putchar(c);
break;
}
}
return 0;
}
27
Running Code on Itself
% gcc upper1.c
% a.out < upper1.c
#Include <Stdio.H>
#Include <Ctype.H>
Int Main(Void) {
Int C; Int State=1;
For ( ; ; ) {
C = Getchar();
If (C == EOF) Break;
Switch (State) {
Case 1:
If (Isalpha(C)) {
Putchar(Toupper(C));
State = 2;
} Else Putchar(C);
Break;
Case 2:
If (!Isalpha(C)) State = 1;
Putchar(C);
Break;
}
}
Return 0;
}
28
OK, That’s a B+
• Works correctly, but
 Mysterious integer constants (“magic numbers”)
 No modularization
 No checking for states besides 1 and 2

• What now?
 States should have names, not just 1,2
 Should handle each state in a separate function
 Good to check for unexpected variable value

29
Improvement: Names for States

• Define your own named constants

 Enumeration of a list of items
 enum Statetype {NORMAL,INWORD};
 Declare a variable of that type
 enum Statetype state;

30
Improvement: Names for States
#include <stdio.h>
#include <ctype.h>
enum Statetype {NORMAL,INWORD};
int main(void) {
int c; enum Statetype state = NORMAL;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
switch (state) {
case NORMAL:
if (isalpha(c)) {
putchar(toupper(c));
state = INWORD;
} else putchar(c);
break;
case INWORD:
if (!isalpha(c)) state = NORMAL;
putchar(c);
break;
}
}
return 0; 31
}
Improvement: Modularity
#include <stdio.h>
#include <ctype.h>
enum Statetype {NORMAL,INWORD};
enum Statetype handleNormalState(int c) {...}
enum Statetype handleInwordState(int c) {...}
int main(void) {
int c;
enum Statetype state = NORMAL;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
switch (state) {
case NORMAL:
state = handleNormalState(c);
break;
case INWORD:
state = handleInwordState(c);
break;
}
}
return 0;
}
32
Improvement: Modularity
enum Statetype handleNormalState(int c) {
enum Statetype state;
if (isalpha(c)) {
putchar(toupper(c));
state = INWORD;
}
else {
putchar(c);
state = NORMAL;
}
return state;
}

33
Improvement: Modularity
enum Statetype handleInwordState(int c) {
enum Statetype state;
putchar(c);
if (!isalpha(c))
state = NORMAL;
else
state = INWORD;
return state;
}

34
Improvement: Defensive Programming
• Assertion checks for diagnostics
 Check that that an expected assumption holds
 Print message to standard error (stderr) when expression is false
 E.g., assert(expression);
 Makes program easier to read, and to debug

switch (state) {
case NORMAL:
…
break;
case INWORD:
…
break; Should never,
default:
assert(0);
ever get here.
}

35
Putting it Together: An “A” Effort
#include <stdio.h>
#include <ctype.h>

enum Statetype {NORMAL,INWORD};

enum Statetype handleNormalState(int c) {

enum Statetype state;
if (isalpha(c)) {
putchar(toupper(c));
state = INWORD;
}
else {
putchar(c);
state = NORMAL;
}
return state;
} 36
Putting it Together: An “A” Effort

enum Statetype handleInwordState(int c) {

enum Statetype state;
putchar(c);
if (!isalpha(c))
state = NORMAL;
else
state = INWORD;
return state;
}

37
Putting it Together: An “A” Effort
int main(void) {
int c;
enum Statetype state = NORMAL;
for ( ; ; ) {
c = getchar();
if (c == EOF) break;
switch (state) {
case NORMAL:
state = handleNormalState(c);
break;
case INWORD:
state = handleInwordState(c);
break;
}
}
return 0;
} 38
Review of Example #3
• Deterministic Finite Automaton
 Two or more states
 Actions in each state, or during transition
 Conditions for transitioning between states

• Expectations for COS 217 assignments

 Modularity (breaking into distinct functions)
 Readability (meaningful names for variables and values)
 Diagnostics (assertion checks to catch mistakes)
 See K&P book for style guidelines specification

39
Another DFA Example
• Does the string have “nano” in it?
 “banano”  yes
 “nnnnnnnanofff”  yes
 “banananonano”  yes
 “bananananashanana”  no
‘n’
‘n’

‘n’ ‘a’ ‘n’ ‘o’

S 1 2 3 F

‘a’

40
Yet Another DFA Example
Question #4 from fall 2005 midterm
Identify whether or not a string is a floating-point number

• Valid numbers • Invalid numbers

 “-34”  “abc”
 “78.1”  “-e9”
 “+298.3”  “1e”
 “-34.7e-1”  “+”
 “34.7E-1”  “17.9A”
 “7.”  “0.38+”
 “.7”  “.”
 “999.99e99”  “38.38f9”

http://www.cs.princeton.edu/courses/archive/fall05/cos217/exams/fall05exam1ans.pdf 41
Conclusions
• Lectures this week
 C fundamentals
 Character I/O
 Deterministic Finite Automata
• Reading this week
 King book: chapters 1-3
• Lectures next week
 Variables pointers and arrays
 Good programming
• Reading for next week
 King book: chapters 4-7
 K&P book: chapters 4 and 5
42