1. Decisions
If statements in C

2. Decision Making: Equality and Relational Operators
Executable statements
Perform actions (calculations, input/output of data)
Perform decisions
May want to print "pass" or "fail" given the value of a test grade
if control structure
If a condition is true, then the body of the if statement executed
0 is false, non-zero is true
Control always resumes after the if structure
Keywords
Special words reserved for C
Cannot be used as identifiers or variable names

3. Decision Making: Equality and Relational Operators

4. Decision Making: Equality and Relational Operators

5. Control Structures Sequential execution
Statements executed one after the other in the order written
All programs written in terms of 3 control structures
Sequence structures: Built into C. Programs executed sequentially by default
Selection structures: C has three types: if, if/else, and switch
Repetition structures: C has three types: while, do/while and for

6. The if Selection Structure
Used to choose among alternative courses of action
Pseudocode:
If student’s grade is greater than or equal to 80 Print “Passed”
If condition true
Print statement executed and program goes on to next statement
If false, print statement is ignored and the program goes onto the next statement
Indenting makes programs easier to read
C ignores whitespace characters

7. The if Selection Structure
Pseudocode statement in C:
if ( grade >= 60 ) printf( "Passed\n" );
C code corresponds closely to the pseudocode

8. The if Selection Structure
if structure is a single-entry/single-exit structure
true
false
grade >= 60
print “Passed”
A decision can be made on any expression.
zero - false
nonzero - true
Example:
3 - 4 is true

9. The if/else Selection Structure
Only performs an action if the condition is true
if/else
Specifies an action to be performed both when the condition is true and when it is false
Psuedocode:
If student’s grade is greater than or equal to 60 Print “Passed”
else Print “Failed”
Note spacing/indentation conventions

10. The if/else Selection Structure
C code:
if ( grade >= 60 )
printf( "Passed\n");
else
printf( "Failed\n");
Ternary conditional operator (?:) DO NOT USE!
Takes three arguments (condition, value if true, value if false)
Our pseudocode could be written:
printf( "%s\n", grade >= 60 ? "Passed" : "Failed" );
Or it could have been written:
grade >= 60 ? printf( “Passed\n” ) : printf( “Failed\n” );

11. The if/else Selection Structure
Flow chart of the if/else selection structure
Nested if/else structures
Test for multiple cases by placing if/else selection structures inside if/else selection structures
Once condition is met, rest of statements skipped
Deep indentation usually not used in practice
true
false
print “Failed”
print “Passed”
grade >= 60

12. The if/else Selection Structure
Pseudocode for a nested if/else structure
If student’s grade is greater than or equal to 90 Print “A” else If student’s grade is greater than or equal to Print “B” else If student’s grade is greater than or equal to Print “C” else If student’s grade is greater than or equal to Print “D” else Print “F”

13. The if/else Selection Structure
Compound statement:
Set of statements within a pair of braces
Example:
if ( grade >= 60 )
printf( "Passed.\n" );
else {
printf( "Failed.\n" );
printf( "You must take this course again.\n" ); }
Without the braces, the statement
printf( "You must take this course again.\n" );
would be executed automatically

14. The if/else Selection Structure
Block:
Compound statements with declarations
Syntax errors
Caught by compiler
Logic errors:
Have their effect at execution time
Non-fatal: program runs, but has incorrect output
Fatal: program exits prematurely

15. isdigit() Function
The isdigit() function is part of the character-handling library <ctype.h>
#include <stdio.h>
#include <ctype.h>
main() {
char cResponse = '\0';
printf("\nPlease enter a letter: ");
scanf("%c", &cResponse);
if ( isdigit(cResponse) == 0 )
printf("\nThank you\n");
else
printf("\nYou did not enter a letter\n"); }

16. INTRODUCTION TO BOOLEAN ALGEBRA
Boolean algebra is named after George Boole, a mathematician in the nineteenth century. Boole developed his own branch of logic containing the values true and false and the operators and, or, and not to manipulate the values. Even though Boole’s work was before the advent of computers, his research has become the foundation of today’s modern digital circuitry in computer architecture.

17. Truth table for and (&&)x y
Result
true
false

18. Truth table for or (||) x y
Result
true
false

19. Solve the following Boolean algebra problems, given x == 5, y == 3, and z == 4 1. x > 3 and z == 4 2. y >= 3 or z > 4 3. NOT(x == 4 or y < z) 4. (z == 5 or x > 3) and (y == z or x < 10)

20. C syntax for compound if statements
if ( 3 > 5 && 5 < 5 ) printf("The entire expression is false\n"); if ( 3 > 5 || 6 < 5 )

21. The switch statement in c
Control statement – replaces multiple if/else statements

22. Example switch statement
switch(n) {
case 0:
printf("You typed zero.\n");
break;
case 1:
printf("n is a perfect square\n");
case 2:
printf("n is an even number\n");
case 3:
case 7:
printf("n is a prime number\n");
case 4:
case 6:
default:
printf("Only single-digit numbers are allowed\n"); }

23. switch (using pre-processor)
#define STATE_READY 1 #define STATE_SET 2 #define STATE_GO 3 #define STATE_FAIL 4 switch( state ) { case STATE_READY: state = STATE_SET; if( x < 0 ) state = STATE_FAIL; break; case STATE_SET: state = STATE_GO; if( y > 0 ) case STATE_GO: printf( "go!\n" ); case STATE_FAIL: exit( -1 ); }

24. Random Numbers
int iRandomNum = 0; srand(time(0)); iRandomNum = (rand() % 4) + 1;

25. Assignment
Finish the 5 problems on page 48
Decisions:

26. 3.8 Formulating Algorithms (Counter-Controlled Repetition)
Loop repeated until counter reaches a certain value
Definite repetition: number of repetitions is known
Example: A class of ten students took a quiz. The grades (integers in the range 0 to 100) for this quiz are available to you. Determine the class average on the quiz
Pseudocode:
Set total to zero Set grade counter to one
While grade counter is less than or equal to ten Input the next grade Add the grade into the total Add one to the grade counter
Set the class average to the total divided by ten Print the class average

27. 1. Initialize Variables 2. Execute Loop 3. Output results
1 /* Fig. 3.6: fig03_06.c
2 Class average program with
3 counter-controlled repetition */
4 #include <stdio.h> 5
6 int main()
7 {
8 int counter, grade, total, average; 9
10 /* initialization phase */
11 total = 0;
12 counter = 1; 13
14 /* processing phase */
15 while ( counter <= 10 ) {
printf( "Enter grade: " );
scanf( "%d", &grade );
total = total + grade;
counter = counter + 1;
20 } 21
22 /* termination phase */
23 average = total / 10;
24 printf( "Class average is %d\n", average ); 25
26 return 0; /* indicate program ended successfully */
27 }
1. Initialize Variables
2. Execute Loop
3. Output results

28. Enter grade: 98 Enter grade: 76 Enter grade: 71 Enter grade: 87
Class average is 81
Program Output

29. 3.9 Formulating Algorithms with Top-Down, Stepwise Refinement
Problem becomes:
Develop a class-averaging program that will process an arbitrary number of grades each time the program is run.
Unknown number of students
How will the program know to end?
Use sentinel value
Also called signal value, dummy value, or flag value
Indicates “end of data entry.”
Loop ends when user inputs the sentinel value
Sentinel value chosen so it cannot be confused with a regular input (such as -1 in this case)

30. 3.9 Formulating Algorithms with Top-Down, Stepwise Refinement
Begin with a pseudocode representation of the top:
Determine the class average for the quiz
Divide top into smaller tasks and list them in order:
Initialize variables Input, sum and count the quiz grades Calculate and print the class average
Many programs have three phases:
Initialization: initializes the program variables
Processing: inputs data values and adjusts program variables accordingly
Termination: calculates and prints the final results

31. 3.9 Formulating Algorithms with Top-Down, Stepwise Refinement
Refine the initialization phase from Initialize variables to:
Initialize total to zero Initialize counter to zero
Refine Input, sum and count the quiz grades to
Input the first grade (possibly the sentinel) While the user has not as yet entered the sentinel Add this grade into the running total Add one to the grade counter Input the next grade (possibly the sentinel)

32. 3.9 Formulating Algorithms with Top-Down, Stepwise Refinement
Refine Calculate and print the class average to
If the counter is not equal to zero Set the average to the total divided by the counter Print the average else Print “No grades were entered”

33. 1. Initialize Variables 2. Get user input 2.1 Perform Loop
1 /* Fig. 3.8: fig03_08.c
2 Class average program with
3 sentinel-controlled repetition */
4 #include <stdio.h> 5
6 int main()
7 {
8 float average; /* new data type */
9 int counter, grade, total; 10
11 /* initialization phase */
12 total = 0;
13 counter = 0; 14
15 /* processing phase */
16 printf( "Enter grade, -1 to end: " );
17 scanf( "%d", &grade ); 18
19 while ( grade != -1 ) {
total = total + grade;
counter = counter + 1;
printf( "Enter grade, -1 to end: " );
scanf( "%d", &grade );
24 }
1. Initialize Variables
2. Get user input
2.1 Perform Loop

34. 3. Calculate Average 3.1 Print Results Program Output25
26 /* termination phase */
27 if ( counter != 0 ) {
average = ( float ) total / counter;
printf( "Class average is %.2f", average );
30 }
31 else
printf( "No grades were entered\n" ); 33
34 return 0; /* indicate program ended successfully */
35 }
3. Calculate Average
3.1 Print Results
Program Output
Enter grade, -1 to end: 75
Enter grade, -1 to end: 94
Enter grade, -1 to end: 97
Enter grade, -1 to end: 88
Enter grade, -1 to end: 70
Enter grade, -1 to end: 64
Enter grade, -1 to end: 83
Enter grade, -1 to end: 89
Enter grade, -1 to end: -1
Class average is 82.50

35. 3.10 Nested control structures
Problem
A college has a list of test results (1 = pass, 2 = fail) for 10 students
Write a program that analyzes the results
If more than 8 students pass, print "Raise Tuition"
Notice that
The program must process 10 test results
Counter-controlled loop will be used
Two counters can be used
One for number of passes, one for number of fails
Each test result is a number—either a 1 or a 2
If the number is not a 1, we assume that it is a 2

36. 3.10 Nested control structures
Top level outline
Analyze exam results and decide if tuition should be raised
First Refinement
Initialize variables
Input the ten quiz grades and count passes and failures
Print a summary of the exam results and decide if tuition should be raised
Refine Initialize variables to
Initialize passes to zero
Initialize failures to zero
Initialize student counter to one

37. 3.10 Nested control structures
Refine Input the ten quiz grades and count passes and failures to
While student counter is less than or equal to ten Input the next exam result
If the student passed
Add one to passes else Add one to failures
Add one to student counter
Refine Print a summary of the exam results and decide if tuition should be raised to
Print the number of passes
Print the number of failures
If more than eight students passed Print “Raise tuition”

38. 2 Analysis of examination results */ 3 #include <stdio.h> 4
1 /* Fig. 3.10: fig03_10.c
2 Analysis of examination results */
3 #include <stdio.h> 4
5 int main()
6 {
7 /* initializing variables in declarations */
8 int passes = 0, failures = 0, student = 1, result; 9
10 /* process 10 students; counter-controlled loop */
11 while ( student <= 10 ) {
printf( "Enter result ( 1=pass,2=fail ): " );
scanf( "%d", &result ); 14
if ( result == 1 ) /* if/else nested in while */
passes = passes + 1;
else
failures = failures + 1; 19
student = student + 1;
21 } 22
23 printf( "Passed %d\n", passes );
24 printf( "Failed %d\n", failures ); 25
26 if ( passes > 8 )
printf( "Raise tuition\n" ); 28
29 return 0; /* successful termination */
30 }
1. Initialize variables
2. Input data and count passes/failures
3. Print results

39. Enter Result (1=pass,2=fail): 1 Enter Result (1=pass,2=fail): 2
Passed 6
Failed 4
Program Output

40. Assignment operators abbreviate assignment expressions
c = c + 3;
can be abbreviated as c += 3; using the addition assignment operator
Statements of the form
variable = variable operator expression;
can be rewritten as
variable operator= expression;
Examples of other assignment operators:
d -= (d = d - 4)
e *= (e = e * 5)
f /= (f = f / 3)
g %= (g = g % 9)

41. 3.12 Increment and Decrement Operators
Increment operator (++)
Can be used instead of c+=1
Decrement operator (--)
Can be used instead of c-=1
Preincrement
Operator is used before the variable (++c or --c)
Variable is changed before the expression it is in is evaluated
Postincrement
Operator is used after the variable (c++ or c--)
Expression executes before the variable is changed

42. 3.12 Increment and Decrement Operators
If c equals 5, then
printf( "%d", ++c );
Prints 6
printf( "%d", c++ );
Prints 5
In either case, c now has the value of 6
When variable not in an expression
Preincrementing and postincrementing have the same effect
++c;
printf( “%d”, c );
Has the same effect as
c++;

43. Chapter 4 - Program Control
Outline
4.1 Introduction
4.2 The Essentials of Repetition
4.3 Counter-Controlled Repetition
4.4 The For Repetition Structure
4.5 The For Structure: Notes and Observations
4.6 Examples Using the For Structure
4.7 The Switch Multiple-Selection Structure
4.8 The Do/While Repetition Structure
4.9 The break and continue Statements
4.10 Logical Operators
4.11 Confusing Equality (==) and Assignment (=) Operators
4.12 Structured Programming Summary

44. This chapter introduces
4.1 Introduction
This chapter introduces
Additional repetition control structures
for
do/while
switch multiple selection structure
break statement
Used for exiting immediately and rapidly from certain control structures
continue statement
Used for skipping the remainder of the body of a repetition structure and proceeding with the next iteration of the loop

45. 4.2 The Essentials of Repetition
Loop
Group of instructions computer executes repeatedly while some condition remains true
Counter-controlled repetition
Definite repetition: know how many times loop will execute
Control variable used to count repetitions
Sentinel-controlled repetition
Indefinite repetition
Used when number of repetitions not known
Sentinel value indicates "end of data"

46. 4.3 Essentials of Counter-Controlled Repetition
Counter-controlled repetition requires
The name of a control variable (or loop counter)
The initial value of the control variable
A condition that tests for the final value of the control variable (i.e., whether looping should continue)
An increment (or decrement) by which the control variable is modified each time through the loop

47. 4.3 Essentials of Counter-Controlled Repetition
Example:
int counter = 1; // initialization
while ( counter <= 10 ) { // repetition condition
printf( "%d\n", counter );
++counter; // increment }
The statement
int counter = 1;
Names counter
Declares it to be an integer
Reserves space for it in memory
Sets it to an initial value of 1

48. 4.4 The for Repetition Structure
Format when using for loops
for ( initialization; loopContinuationTest; increment ) statement
Example:
for( int counter = 1; counter <= 10; counter++ )
printf( "%d\n", counter );
Prints the integers from one to ten
No semicolon (;) after last expression

49. 4.4 The for Repetition Structure
For loops can usually be rewritten as while loops:
initialization; while ( loopContinuationTest ) { statement; increment; }
Initialization and increment
Can be comma-separated lists
Example:
for (int i = 0, j = 0; j + i <= 10; j++, i++)
printf( "%d\n", j + i );

50. 4.5 The for Structure: Notes and Observations
Arithmetic expressions
Initialization, loop-continuation, and increment can contain arithmetic expressions. If x equals 2 and y equals 10
for ( j = x; j <= 4 * x * y; j += y / x )
is equivalent to
for ( j = 2; j <= 80; j += 5 )
Notes about the for structure:
"Increment" may be negative (decrement)
If the loop continuation condition is initially false
The body of the for structure is not performed
Control proceeds with the next statement after the for structure
Control variable
Often printed or used inside for body, but not necessary

51. Initialize variables for repetition structure Program Output
1 /* Fig. 4.5: fig04_05.c
2 Summation with for */
3 #include <stdio.h> 4
5 int main()
6 {
7 int sum = 0, number; 8
9 for ( number = 2; number <= 100; number += 2 )
sum += number; 11
12 printf( "Sum is %d\n", sum ); 13
14 return 0;
15 }
Initialize variables
for repetition structure
Program Output
Sum is 2550

52. 4.7 The switch Multiple-Selection Structure
Useful when a variable or expression is tested for all the values it can assume and different actions are taken
Format
Series of case labels and an optional default case
switch ( value ){
case '1':
actions
case '2':
default: }
break; exits from structure

53. 4.7 The switch Multiple-Selection Structure
Flowchart of the switch structure
true
false .
case a
case a action(s)
break
case b
case b action(s)
case z
case z action(s)
default action(s)

54. 2 Counting letter grades */ 3 #include <stdio.h> 4 5 int main()
1 /* Fig. 4.7: fig04_07.c
2 Counting letter grades */
3 #include <stdio.h> 4
5 int main()
6 {
7 int grade;
8 int aCount = 0, bCount = 0, cCount = 0,
dCount = 0, fCount = 0; 10
11 printf( "Enter the letter grades.\n" );
12 printf( "Enter the EOF character to end input.\n" ); 13
14 while ( ( grade = getchar() ) != EOF ) { 15
switch ( grade ) { /* switch nested in while */ 17
case 'A': case 'a': /* grade was uppercase A */
aCount; /* or lowercase a */
break; 21
case 'B': case 'b': /* grade was uppercase B */
bCount; /* or lowercase b */
break; 25
case 'C': case 'c': /* grade was uppercase C */
cCount; /* or lowercase c */
break; 29
case 'D': case 'd': /* grade was uppercase D */
dCount; /* or lowercase d */
break;
1. Initialize variables
2. Input data
2.1 Use switch loop to update count

55. 2.1 Use switch loop to update count 3. Print results33
case 'F': case 'f': /* grade was uppercase F */
fCount; /* or lowercase f */
break; 37
case '\n': case' ': /* ignore these in input */
break; 40
default: /* catch all other characters */
printf( "Incorrect letter grade entered." );
printf( " Enter a new grade.\n" );
break; }
46 } 47
48 printf( "\nTotals for each letter grade are:\n" );
49 printf( "A: %d\n", aCount );
50 printf( "B: %d\n", bCount );
51 printf( "C: %d\n", cCount );
52 printf( "D: %d\n", dCount );
53 printf( "F: %d\n", fCount ); 54
55 return 0;
56 }
2.1 Use switch loop to update count
3. Print results

56. Enter the letter grades. Enter the EOF character to end input. A B C
Incorrect letter grade entered. Enter a new grade.
Totals for each letter grade are:
A: 3
B: 2
C: 3
D: 2
F: 1
Program Output

57. 4.8 The do/while Repetition Structure
Similar to the while structure
Condition for repetition tested after the body of the loop is performed
All actions are performed at least once
Format:
do {
statement;
} while ( condition );

58. 4.8 The do/while Repetition Structure
Example (letting counter = 1):
do {
printf( "%d ", counter );
} while (++counter <= 10);
Prints the integers from 1 to 10

59. 4.8 The do/while Repetition Structure
Flowchart of the do/while repetition structure
true
false
action(s)
condition

60. 1. Initialize variable 2. Loop 3. Print Program Output
1 /* Fig. 4.9: fig04_09.c
2 Using the do/while repetition structure */
3 #include <stdio.h> 4
5 int main()
6 {
7 int counter = 1; 8
9 do {
printf( "%d ", counter );
11 } while ( ++counter <= 10 ); 12
13 return 0;
14 }
1. Initialize variable
2. Loop
3. Print
Program Output

61. 4.9 The break and continue Statements
Causes immediate exit from a while, for, do/while or switch structure
Program execution continues with the first statement after the structure
Common uses of the break statement
Escape early from a loop
Skip the remainder of a switch structure

62. 4.9 The break and continue Statements
Skips the remaining statements in the body of a while, for or do/while structure
Proceeds with the next iteration of the loop
while and do/while
Loop-continuation test is evaluated immediately after the continue statement is executed
for
Increment expression is executed, then the loop-continuation test is evaluated

63. 1. Initialize variable 2. Loop 3. Print Program Output
1 /* Fig. 4.12: fig04_12.c
2 Using the continue statement in a for structure */
3 #include <stdio.h> 4
5 int main()
6 {
7 int x; 8
9 for ( x = 1; x <= 10; x++ ) { 10
if ( x == 5 )
continue; /* skip remaining code in loop only
if x == 5 */ 14
printf( "%d ", x );
16 } 17
18 printf( "\nUsed continue to skip printing the value 5\n" );
19 return 0;
20 }
1. Initialize variable
2. Loop
3. Print
Program Output
Used continue to skip printing the value 5

64. ! ( logical NOT, logical negation )
4.10 Logical Operators
&& ( logical AND )
Returns true if both conditions are true
|| ( logical OR )
Returns true if either of its conditions are true
! ( logical NOT, logical negation )
Reverses the truth/falsity of its condition
Unary operator, has one operand
Useful as conditions in loops
Expression Result
true && false false true || false true
!false true

65. 4.11 Confusing Equality (==) and Assignment (=) Operators
Dangerous error
Does not ordinarily cause syntax errors
Any expression that produces a value can be used in control structures
Nonzero values are true, zero values are false
Example using ==:
if ( payCode == 4 )
printf( "You get a bonus!\n" );
Checks paycode, if it is 4 then a bonus is awarded

66. 4.11 Confusing Equality (==) and Assignment (=) Operators
Example, replacing == with =:
if ( payCode = 4 )
printf( "You get a bonus!\n" );
This sets paycode to 4
4 is nonzero, so expression is true, and bonus awarded no matter what the paycode was
Logic error, not a syntax error

67. 4.11 Confusing Equality (==) and Assignment (=) Operators
lvalues
Expressions that can appear on the left side of an equation
Their values can be changed, such as variable names
x = 4;
rvalues
Expressions that can only appear on the right side of an equation
Constants, such as numbers
Cannot write 4 = x;
Must write x = 4;
lvalues can be used as rvalues, but not vice versa
y = x;

68. 4.12 Structured-Programming Summary
Easier than unstructured programs to understand, test, debug and, modify programs
Rules for structured programming
Rules developed by programming community
Only single-entry/single-exit control structures are used
Rules:
Begin with the “simplest flowchart”
Any rectangle (action) can be replaced by two rectangles (actions) in sequence
Any rectangle (action) can be replaced by any control structure (sequence, if, if/else, switch, while, do/while or for)
Rules 2 and 3 can be applied in any order and multiple times

69. 4.12 Structured-Programming Summary
Rule 2 - Any rectangle can be replaced by two rectangles in sequence
Rule 1 - Begin with the simplest flowchart .
. .
Rule 2

70. 4.12 Structured-Programming Summary
Rule 3 - Replace any rectangle with a control structure
Rule 3
Rule 3
Rule 3

71. 4.12 Structured-Programming Summary
All programs can be broken down into 3 controls
Sequence – handled automatically by compiler
Selection – if, if/else or switch
Repetition – while, do/while or for
Can only be combined in two ways
Nesting (rule 3)
Stacking (rule 2)
Any selection can be rewritten as an if statement, and any repetition can be rewritten as a while statement

72. Chapter 5 - Functions Outline 5.1 Introduction
5.2 Program Modules in C
5.3 Math Library Functions
5.4 Functions
5.5 Function Definitions
5.6 Function Prototypes
5.7 Header Files
5.8 Calling Functions: Call by Value and Call by Reference
5.9 Random Number Generation
5.10 Example: A Game of Chance
5.11 Storage Classes
5.12 Scope Rules
5.13 Recursion
5.14 Example Using Recursion: The Fibonacci Series
5.15 Recursion vs. Iteration

73. 5.1 Introduction Divide and conquer
Construct a program from smaller pieces or components
These smaller pieces are called modules
Each piece more manageable than the original program

74. 5.2 Program Modules in C Functions Function calls Invoking functions
Programs combine user-defined functions with library functions
C standard library has a wide variety of functions
Function calls
Invoking functions
Provide function name and arguments (data)
Function performs operations or manipulations
Function returns results
Function call analogy:
Boss asks worker to complete task
Worker gets information, does task, returns result
Information hiding: boss does not know details

75. 5.3 Math Library Functions
perform common mathematical calculations
#include <math.h>
Format for calling functions
FunctionName( argument );
If multiple arguments, use comma-separated list
printf( "%.2f", sqrt( ) );
Calls function sqrt, which returns the square root of its argument
All math functions return data type double
Arguments may be constants, variables, or expressions

76. 5.4 Functions Functions Benefits of functions Modularize a program
All variables declared inside functions are local variables
Known only in function defined
Parameters
Communicate information between functions
Local variables
Benefits of functions
Divide and conquer
Manageable program development
Software reusability
Use existing functions as building blocks for new programs
Abstraction - hide internal details (library functions)
Avoid code repetition

77. Function definition format
5.5 Function Definitions
Function definition format
return-value-type function-name( parameter-list ) { declarations and statements }
Function-name: any valid identifier
Return-value-type: data type of the result (default int)
void – indicates that the function returns nothing
Parameter-list: comma separated list, declares parameters
A type must be listed explicitly for each parameter unless, the parameter is of type int

78. Function definition format (continued)
5.5 Function Definitions
Function definition format (continued)
return-value-type function-name( parameter-list ) { declarations and statements }
Declarations and statements: function body (block)
Variables can be declared inside blocks (can be nested)
Functions can not be defined inside other functions
Returning control
If nothing returned
return;
or, until reaches right brace
If something returned
return expression;

79. 2 Finding the maximum of three integers */ 3 #include <stdio.h>
1 /* Fig. 5.4: fig05_04.c
2 Finding the maximum of three integers */
3 #include <stdio.h> 4
5 int maximum( int, int, int ); /* function prototype */ 6
7 int main()
8 {
9 int a, b, c; 10
11 printf( "Enter three integers: " );
12 scanf( "%d%d%d", &a, &b, &c );
13 printf( "Maximum is: %d\n", maximum( a, b, c ) ); 14
15 return 0;
16 } 17
18 /* Function maximum definition */
19 int maximum( int x, int y, int z )
20 {
21 int max = x; 22
23 if ( y > max )
max = y; 25
26 if ( z > max )
max = z; 28
29 return max;
30 }
1. Function prototype (3 parameters)
2. Input values
2.1 Call function
Function definition
Program Output
Enter three integers:
Maximum is: 85

80. Promotion rules and conversions
5.6 Function Prototypes
Function prototype
Function name
Parameters – what the function takes in
Return type – data type function returns (default int)
Used to validate functions
Prototype only needed if function definition comes after use in program
The function with the prototype
int maximum( int, int, int );
Takes in 3 ints
Returns an int
Promotion rules and conversions
Converting to lower types can lead to errors

81. 5.7 Header Files Header files Custom header files
Contain function prototypes for library functions
<stdlib.h> , <math.h> , etc
Load with #include <filename>
#include <math.h>
Custom header files
Create file with functions
Save as filename.h
Load in other files with #include "filename.h"
Reuse functions

82. 5.8 Calling Functions: Call by Value and Call by Reference
Used when invoking functions
Call by value
Copy of argument passed to function
Changes in function do not effect original
Use when function does not need to modify argument
Avoids accidental changes
Call by reference
Passes original argument
Changes in function effect original
Only used with trusted functions
For now, we focus on call by value

83. 5.9 Random Number Generation
rand function
Load <stdlib.h>
Returns "random" number between 0 and RAND_MAX (at least 32767)
i = rand();
Pseudorandom
Preset sequence of "random" numbers
Same sequence for every function call
Scaling
To get a random number between 1 and n
1 + ( rand() % n )
rand() % n returns a number between 0 and n - 1
Add 1 to make random number between 1 and n
1 + ( rand() % 6)
number between 1 and 6

84. 5.9 Random Number Generation
srand function
<stdlib.h>
Takes an integer seed and jumps to that location in its "random" sequence
srand( seed );
srand( time( NULL ) ); //load <time.h>
time( NULL )
Returns the time at which the program was compiled in seconds
“Randomizes" the seed

85. 2 Randomizing die-rolling program */ 3 #include <stdlib.h>
1 /* Fig. 5.9: fig05_09.c
2 Randomizing die-rolling program */
3 #include <stdlib.h>
4 #include <stdio.h> 5
6 int main()
7 {
8 int i;
9 unsigned seed; 10
11 printf( "Enter seed: " );
12 scanf( "%u", &seed );
13 srand( seed ); 14
15 for ( i = 1; i <= 10; i++ ) {
printf( "%10d", 1 + ( rand() % 6 ) ); 17
if ( i % 5 == 0 )
printf( "\n" );
20 } 21
22 return 0;
23 }
1. Initialize seed
2. Input value for seed
2.1 Use srand to change random sequence
2.2 Define Loop
3. Generate and output random numbers

86. Enter seed: 67 6 1 4 6 2 1 6 1 6 4 Enter seed: 867 2 4 6 1 6 1 1 3 6 2
Program Output
Enter seed: 867
Enter seed: 67

87. 5.10 Example: A Game of Chance
Craps simulator
Rules
Roll two dice
7 or 11 on first throw, player wins
2, 3, or 12 on first throw, player loses
4, 5, 6, 8, 9, 10 - value becomes player's "point"
Player must roll his point before rolling 7 to win

88. 3 #include <stdio.h> 4 #include <stdlib.h>
1 /* Fig. 5.10: fig05_10.c
2 Craps */
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <time.h> 6
7 int rollDice( void ); 8
9 int main()
10 {
11 int gameStatus, sum, myPoint; 12
13 srand( time( NULL ) );
14 sum = rollDice(); /* first roll of the dice */ 15
16 switch ( sum ) {
case 7: case 11: /* win on first roll */
gameStatus = 1;
break;
case 2: case 3: case 12: /* lose on first roll */
gameStatus = 2;
break;
default: /* remember point */
gameStatus = 0;
myPoint = sum;
printf( "Point is %d\n", myPoint );
break;
28 } 29
30 while ( gameStatus == 0 ) { /* keep rolling */
sum = rollDice(); 32
1. rollDice prototype
1.1 Initialize variables
1.2 Seed srand
2. Define switch statement for win/loss/continue
2.1 Loop

89. 2.2 Print win/loss Program Output
if ( sum == myPoint ) /* win by making point */
gameStatus = 1;
else
if ( sum == 7 ) /* lose by rolling 7 */
gameStatus = 2;
38 } 39
40 if ( gameStatus == 1 )
printf( "Player wins\n" );
42 else
printf( "Player loses\n" ); 44
45 return 0;
46 } 47
48 int rollDice( void )
49 {
50 int die1, die2, workSum; 51
52 die1 = 1 + ( rand() % 6 );
53 die2 = 1 + ( rand() % 6 );
54 workSum = die1 + die2;
55 printf( "Player rolled %d + %d = %d\n", die1, die2, workSum );
56 return workSum;
57 }
2.2 Print win/loss
Program Output
Player rolled = 11
Player wins

90. Player rolled 6 + 6 = 12 Player loses Player rolled 4 + 6 = 10
Point is 10
Player rolled = 6
Player rolled = 11
Player rolled = 6
Player rolled = 10
Player wins
Program Output
Player rolled = 4
Point is 4
Player rolled = 5
Player rolled = 9
Player rolled = 10
Player rolled = 9
Player rolled = 3
Player rolled = 7
Player loses

91. Storage class specifiers
5.11 Storage Classes
Storage class specifiers
Storage duration – how long an object exists in memory
Scope – where object can be referenced in program
Linkage – specifies the files in which an identifier is known (more in Chapter 14)
Automatic storage
Object created and destroyed within its block
auto: default for local variables
auto double x, y;
register: tries to put variable into high-speed registers
Can only be used for automatic variables
register int counter = 1;

92. 5.11 Storage Classes Static storage
Variables exist for entire program execution
Default value of zero
static: local variables defined in functions.
Keep value after function ends
Only known in their own function
extern: default for global variables and functions
Known in any function

93. 5.12 Scope Rules File scope Function scope
Identifier defined outside function, known in all functions
Used for global variables, function definitions, function prototypes
Function scope
Can only be referenced inside a function body
Used only for labels (start:, case: , etc.)

94. Function prototype scope
5.12 Scope Rules
Block scope
Identifier declared inside a block
Block scope begins at declaration, ends at right brace
Used for variables, function parameters (local variables of function)
Outer blocks "hidden" from inner blocks if there is a variable with the same name in the inner block
Function prototype scope
Used for identifiers in parameter list

95. 3 #include <stdio.h> 4
1 /* Fig. 5.12: fig05_12.c
2 A scoping example */
3 #include <stdio.h> 4
5 void a( void ); /* function prototype */
6 void b( void ); /* function prototype */
7 void c( void ); /* function prototype */ 8
9 int x = 1; /* global variable */ 10
11 int main()
12 {
13 int x = 5; /* local variable to main */ 14
15 printf("local x in outer scope of main is %d\n", x ); 16
17 { /* start new scope */
int x = 7; 19
printf( "local x in inner scope of main is %d\n", x );
21 } /* end new scope */ 22
23 printf( "local x in outer scope of main is %d\n", x ); 24
25 a(); /* a has automatic local x */
26 b(); /* b has static local x */
27 c(); /* c uses global x */
28 a(); /* a reinitializes automatic local x */
29 b(); /* static local x retains its previous value */
30 c(); /* global x also retains its value */
1. Function prototypes
1.1 Initialize global variable
1.2 Initialize local variable
1.3 Initialize local variable in block
2. Call functions
3. Output results

96. 32 printf( "local x in main is %d\n", x ); 33 return 0; 34 } 35 31
32 printf( "local x in main is %d\n", x );
33 return 0;
34 } 35
36 void a( void )
37 {
38 int x = 25; /* initialized each time a is called */ 39
40 printf( "\nlocal x in a is %d after entering a\n", x ); x;
42 printf( "local x in a is %d before exiting a\n", x );
43 } 44
45 void b( void )
46 {
static int x = 50; /* static initialization only */
/* first time b is called */
printf( "\nlocal static x is %d on entering b\n", x ); x;
printf( "local static x is %d on exiting b\n", x );
52 } 53
54 void c( void )
55 {
56 printf( "\nglobal x is %d on entering c\n", x );
57 x *= 10;
58 printf( "global x is %d on exiting c\n", x );
59 }
3.1 Function definitions

97. local x in outer scope of main is 5
local x in inner scope of main is 7
local x in a is 25 after entering a
local x in a is 26 before exiting a
local static x is 50 on entering b
local static x is 51 on exiting b
global x is 1 on entering c
global x is 10 on exiting c
local static x is 51 on entering b
local static x is 52 on exiting b
global x is 10 on entering c
global x is 100 on exiting c
local x in main is 5
Program Output

98. 5.13 Recursion Recursive functions Functions that call themselves
Can only solve a base case
Divide a problem up into
What it can do
What it cannot do
What it cannot do resembles original problem
The function launches a new copy of itself (recursion step) to solve what it cannot do
Eventually base case gets solved
Gets plugged in, works its way up and solves whole problem

99. 5.13 Recursion Example: factorials 5! = 5 * 4 * 3 * 2 * 1 Notice that
5! = 5 * 4!
4! = 4 * 3! ...
Can compute factorials recursively
Solve base case (1! = 0! = 1) then plug in
2! = 2 * 1! = 2 * 1 = 2;
3! = 3 * 2! = 3 * 2 = 6;

100. 5.14 Example Using Recursion: The Fibonacci Series
Each number is the sum of the previous two
Can be solved recursively:
fib( n ) = fib( n - 1 ) + fib( n – 2 )
Code for the fibaonacci function
long fibonacci( long n ) {
if (n == 0 || n == 1) // base case
return n;
else
return fibonacci( n - 1) fibonacci( n – 2 ); }

101. 5.14 Example Using Recursion: The Fibonacci Series
Set of recursive calls to function fibonacci
f( 3 )
f( 1 )
f( 2 )
f( 0 )
return 1
return 0
return +

102. 2 Recursive fibonacci function */ 3 #include <stdio.h> 4
1 /* Fig. 5.15: fig05_15.c
2 Recursive fibonacci function */
3 #include <stdio.h> 4
5 long fibonacci( long ); 6
7 int main()
8 {
9 long result, number; 10
11 printf( "Enter an integer: " );
12 scanf( "%ld", &number );
13 result = fibonacci( number );
14 printf( "Fibonacci( %ld ) = %ld\n", number, result );
15 return 0;
16 } 17
18 /* Recursive definition of function fibonacci */
19 long fibonacci( long n )
20 {
21 if ( n == 0 || n == 1 )
return n;
23 else
return fibonacci( n - 1 ) + fibonacci( n - 2 );
25 }
1. Function prototype
1.1 Initialize variables
2. Input an integer
2.1 Call function fibonacci
2.2 Output results.
3. Define fibonacci recursively
Program Output
Enter an integer: 0
Fibonacci(0) = 0
Enter an integer: 1
Fibonacci(1) = 1

103. Enter an integer: 2 Fibonacci(2) = 1 Enter an integer: 3
Program Output

104. 5.15 Recursion vs. Iteration
Repetition
Iteration: explicit loop
Recursion: repeated function calls
Termination
Iteration: loop condition fails
Recursion: base case recognized
Both can have infinite loops
Balance
Choice between performance (iteration) and good software engineering (recursion)