1

5
C Functions

 2007 Pearson Education, Inc. All rights reserved.

 2

OBJECTIVES
In this chapter you will learn:
▪ To construct programs modularly from small pieces
called functions.
▪ The common math functions available in the C
Standard Library.
▪ To create new functions.
▪ The mechanisms used to pass information between
functions.
▪ Simulation techniques using random number
generation.
▪ How to write and use recursive functions, i.e., functions
that call themselves.

 2007 Pearson Education, Inc. All rights reserved.

 3

5.1 Introduction
Why functions?
Break longer jobs into conceptually smaller jobs which are
precisely defined.
C program generally consists of many small functions.
A piece of a code which repeats at many places can be
written only once and used again and again.
Debugging and maintenance is easy

 2007 Pearson Education, Inc. All rights reserved.

 4

5.2 Functions in C
C standard library has a wide variety of functions

 2007 Pearson Education, Inc. All rights reserved.

 5

5.3 Math Library Functions

▪ Math library functions
– perform common mathematical calculations
– #include <math.h>
Function Description Example

floor( x ) rounds x to the largest integer floor( 9.2 ) is 9.0

not greater than x
floor( -9.8 ) is -10.0

pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128.0

pow( 9, .5 ) is 3.0

fmod( x, y ) remainder of x/y as a floating- fmod( 13.657, 2.333 ) is 1.992

point number

sin( x ) trigonometric sine of x sin( 0.0 ) is 0.0

(x in radians)

cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0

(x in radians)

tan( x ) trigonometric tangent of x tan( 0.0 ) is 0.0

(x in radians)

 2007 Pearson Education, Inc. All rights reserved.

 6

Function Description Example

sqrt( x ) square root of x sqrt( 900.0 ) is 30.0

sqrt( 9.0 ) is 3.0

exp( x ) exponential function ex exp( 1.0 ) is 2.718282

exp( 2.0 ) is 7.389056

log( x ) natural logarithm of x (base e) log( 2.718282 ) is 1.0

log( 7.389056 ) is 2.0

log10( x ) logarithm of x (base 10) log10( 1.0 ) is 0.0

log10( 10.0 ) is 1.0
log10( 100.0 ) is 2.0

fabs( x ) absolute value of x fabs( 5.0 ) is 5.0

fabs( 0.0 ) is 0.0
fabs( -5.0 ) is 5.0

ceil( x ) rounds x to the smallest integer ceil( 9.2 ) is 10.0

not less than x ceil( -9.8 ) is -9.0

Fig. 5.2 | Commonly used math library functions. (Part 1 of 2.)

 2007 Pearson Education, Inc. All rights reserved.

 7

Boss asks worker to complete task, Worker gets information, does

task, returns result. Information hiding: boss does not know
details.

Fig. 5.1 | Hierarchical boss function/worker function relationship.

 2007 Pearson Education, Inc. All rights reserved.

 8

#include <math.h>

statement adds (preprocessor directive ) all the codes

(functions) from the math.h file into our code.

Therefore, all the functions which are defined in math.h

file are ready for our usage.
 9

For example: If you want to use sqrt() function, the header

file <math.h> should be included.

#include <stdio.h>

int main() {

// If you use sqrt() function without including the <math.h>

// header file, this program will show an error.

sqrt(900);

 2007 Pearson Education, Inc. All rights reserved.

 10

Format for calling functions

functionName ( argument );
- If multiple arguments, use comma-separated list

sqrt(900.0);
- 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

 2007 Pearson Education, Inc. All rights reserved.

 11

Good Programming Practice 5.1

Familiarize yourself with the rich collection

of functions in the C Standard Library.

Avoid reinventing the wheel. When possible,

use C Standard Library functions instead of
writing new functions.

 2007 Pearson Education, Inc. All rights reserved.

 12

Portability Tip 5.1

Using the functions in the C Standard
Library helps make programs more portable.

 2007 Pearson Education, Inc. All rights reserved.

 13

Software Engineering Observation 5.2

All C programs must have one, and only

one, main function

 2007 Pearson Education, Inc. All rights reserved.

 14

5.5 Function Definitions

if we want to define a new function

Return-value-type: data type of the result function-name: any

(default int). void – indicates that the valid identifier
function returns nothing

return-value-type function-name( parameter-list )

{
declarations and statements
}

– Parameter-list: comma separated list, declares parameters

 2007 Pearson Education, Inc. All rights reserved.

 15

5.5 Function Definitions

return-value-type function-name( parameter-list )
{
declarations and statements
}

function body

- Variables can be defined inside blocks (function body)

- Functions can not be defined inside other functions

// function definition
int max(int a){
int b=100;
return a>b ? a : b;
}

 2007 Pearson Education, Inc. All rights reserved.

 16

5.5 Function Definitions

return-value-type function-name( parameter-list )
{
declarations and statements
return;
}
return-value-type function-name( parameter-list )
{
declarations and statements
}

nothing returns

 2007 Pearson Education, Inc. All rights reserved.

 17

5.5 Function Definitions

// function definition
int max(int a){
int b=100;
return a>b ? a : b;
}

returns an integer value

 2007 Pearson Education, Inc. All rights reserved.

Function Definition Example
int max(int a, int b);
Function prototype indicates function
will be defined later in the program
int main() {
int x;
x = max(5,8);
Function is called
x = max(x,7);
} // end of main function

// function definition
int max(int a, int b){ Function definition
return a>b ? a : b;
}

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.3: fig05_03.c 19
2 Creating and using a programmer-defined function */
3 #include <stdio.h>
Outline
4
5 int square( int y ); /* function prototype */
6
7 /* function main begins program execution */
Function prototype indicates function
8 int main( void ) will be defined later in the program
9 {
10 int x; /* counter */
11
12 /* loop 10 times and calculate and output square of x each time */
13 for ( x = 1; x <= 10; x++ ) {
14 printf( "%d ", square( x ) ); /* function call */
15 } /* end for */
16
Call to square function
17 printf( "\n" );
18 Place a blank line between
19 return 0; /* indicates successful termination */ function definitions to separate
20 the functions and enhance
21 } /* end main */
22
program readability.
23 /* square function definition returns square of parameter */
24 int square( int y ) /* y is a copy of argument to function */ Function definition
25 {
26 return y * y; /* returns square of y as an int */
27
28 } /* end function square */

1 4 9 16 25 36 49 64 81 100

 2007 Pearson Education,

Inc. All rights reserved.
 20

Common Programming Error 5.1

Omitting the return-value-type in a function
definition is a syntax error if the function prototype
specifies a return type other than int.
double sample_f (parameter-list );

int main {
… }

sample_f ( parameter-list )
{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 21

Common Programming Error 5.2

Forgetting to return a value from a function that is
supposed to return a value can lead to unexpected
errors. The C standard states that the result of this
omission is undefined.
double sample_f (parameter-list );

int main {
… }

double sample_f ( parameter-list )

{
declarations and statements
}

 2007 Pearson Education, Inc. All rights reserved.

 22

Common Programming Error 5.3

Returning a value from a function with a void
return type is a syntax error.
void sample_f (parameter-list );

int main {
… }

Void sample_f ( parameter-list )

{
declarations and statements, calculations of x

return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 23

Good Programming Practice 5.3

Even though an omitted return type defaults to int,
always state the return type explicitly.

sample_f (parameter-list );

int main {
… }

sample_f ( parameter-list )
{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 24

Common Programming Error 5.4

Specifying function parameters of the same type as double x, y
instead of double x, double y might cause errors in your programs.
The parameter declaration double x, y would actually make y a
parameter of type int because int is the default.
double sample_f (double x, y );

int main {
… } y is declared as
integer
double sample_f ( double x, y )
{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 25

Good Programming Practice 5.4

Include the type of each parameter in the parameter
list, even if that parameter is of the default type int.
double sample_f (int x, int y );

int main {
… }

double sample_f ( int x, int y )

{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 26

Common Programming Error 5.7

Defining a function inside another function
is a syntax error.

 2007 Pearson Education, Inc. All rights reserved.

 27

Good Programming Practice 5.6

Choosing meaningful function names and meaningful

parameter names makes programs more readable and
helps avoid excessive use of comments.

 2007 Pearson Education, Inc. All rights reserved.

 28

Software Engineering Observation 5.6

Programs should be written as collections of small
functions. This makes programs easier to write,
debug, maintain and modify.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.4: fig05_04.c 29
2 Finding the maximum of three integers */
3 #include <stdio.h>
Outline
4
5 int maximum( int x, int y, int z ); /* function prototype */
6
fig05_04.c
7 /* function main begins program execution */ Function prototype
8 int main( void )
9 {
(1 of 2 )
10 int number1; /* first integer */
11 int number2; /* second integer */
12 int number3; /* third integer */
13
14 printf( "Enter three integers: " );
15 scanf( "%d%d%d", &number1, &number2, &number3 );
16 Function call
17 /* number1, number2 and number3 are arguments
18 to the maximum function call */
19 printf( "Maximum is: %d\n", maximum( number1, number2, number3 ) );
20
21 return 0; /* indicates successful termination */
22
23 } /* end main */
24

Function prototype indicates function

will be defined later in the program

 2007 Pearson Education,

Inc. All rights reserved.
25 /* Function maximum definition */ 30
26 /* x, y and z are parameters */
27 int maximum( int x, int y, int z ) Function definition
Outline
28 {
29 int max = x; /* assume x is largest */
30
fig05_04.c
31 if ( y > max ) { /* if y is larger than max, assign y to max */
32 max = y;
33 } /* end if */
(2 of 2 )
34
35 if ( z > max ) { /* if z is larger than max, assign z to max */
36 max = z;
37 } /* end if */
38
39 return max; /* max is largest value */
40
41 } /* end function maximum */

Enter three integers: 22 85 17

Maximum is: 85

Enter three integers: 85 22 17

Maximum is: 85

Enter three integers: 22 17 85

Maximum is: 85

 2007 Pearson Education,

Inc. All rights reserved.
 31

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 x, int y, int z );
- Takes in 3 ints
- Returns an int

 2007 Pearson Education, Inc. All rights reserved.

 32

Common Programming Error 5.8

Forgetting the semicolon at the end of a function
prototype is a syntax error.
double sample_f (int x,int y ) ;

int main {
… }

double sample_f ( int x, int y )

{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 33

printf conversion scanf conversion

Data type
specification specification

Long double %Lf %Lf

double %f %lf higher data
float %f %f types
Unsigned long int %lu %lu
long int %ld %ld

unsigned int %u %u
int %d %d
unsigned short %hu %hu
short %hd %hd
char %c %c
Converting to
Fig. 5.5 | Promotion hierarchy for data types. lower data types
can lead to
errors

 2007 Pearson Education, Inc. All rights reserved.

 34

Common Programming Error 5.9

Converting from a higher data type in the promotion
hierarchy to a lower type can change the data value.
int sample_f (double x, double y );

int main {
… }

int sample_f (double x, double y );

{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 35

Common Programming Error 5.10

Forgetting a function prototype causes a syntax error
if the function definition appears after the function
call in the program.
int main {
sample_f (3,4); /* function call */
… }

// function definition
int sample_f ( int x, int y )
{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 36

Software Engineering Observation 5.9

A function prototype placed in a function applies only to
calls made in that function.
int main {
int sample_f (int x,int y ); function prototype
sample_f(3,4);
… }

int sample_f ( int x, int y )

{
declarations and statements, calculations of x
return x;
}

 2007 Pearson Education, Inc. All rights reserved.

 37

5.7 Function Call Stack and Activation

Records
▪ Program execution stack
– A stack is a last-in, first-out (LIFO) data structure
- Anything put into the stack is placed “on top”
- The only data that can be taken out is the data on top
– C uses a program execution stack to keep track of which
functions have been called
- When a function is called, it is placed on top of the stack
- When a function ends, it is taken off the stack and control returns
to the function immediately below it
– Calling more functions than C can handle at once is known as
a “stack overflow error”

 2007 Pearson Education, Inc. All rights reserved.

 38

5.8 Headers
▪ 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

 2007 Pearson Education, Inc. All rights reserved.

 39

Standard library header Explanation

<assert.h> Contains macros and information for adding diagnostics that aid
program debugging.
<ctype.h> Contains function prototypes for functions that test characters for
certain properties, and function prototypes for functions that can
be used to convert lowercase letters to uppercase letters and vice
versa.
<errno.h> Defines macros that are useful for reporting error conditions.
<float.h> Contains the floating-point size limits of the system.
<limits.h> Contains the integral size limits of the system.
<locale.h> Contains function prototypes and other information that enables a
program to be modified for the current locale on which it is
running. The notion of locale enables the computer system to
handle different conventions for expressing data like dates, times,
dollar amounts and large numbers throughout the world.

Fig. 5.6 | Some of the standard library headers. (Part 1 of 3.)

 2007 Pearson Education, Inc. All rights reserved.

 40

Standard library header Explanation

<math.h> Contains function prototypes for math library functions.

<setjmp.h> Contains function prototypes for functions that allow bypassing of
the usual function call and return sequence.
<signal.h> Contains function prototypes and macros to handle various
conditions that may arise during program execution.
<stdarg.h> Defines macros for dealing with a list of arguments to a function
whose number and types are unknown.
<stddef.h> Contains common definitions of types used by C for performing
certain calculations.

Fig. 5.6 | Some of the standard library headers. (Part 2 of 3.)

 2007 Pearson Education, Inc. All rights reserved.

 41

Standard library header Explanation

<stdio.h> Contains function prototypes for the standard input/output library

functions, and information used by them.
<stdlib.h> Contains function prototypes for conversions of numbers to text
and text to numbers, memory allocation, random numbers, and
other utility functions.
<string.h> Contains function prototypes for string-processing functions.
<time.h> Contains function prototypes and types for manipulating the time
and date.

Fig. 5.6 | Some of the standard library headers. (Part 3 of 3.)

 2007 Pearson Education, Inc. All rights reserved.

 42

5.9 Calling Functions: Call-by-Value and

Call-by-Reference call by value
▪ Call by value
– Copy of argument passed to function int main {
– Changes in function do not effect original sample_f(3,4); /* function call */
– Use when function does not need to modify … }
argument
int sample_f ( int x, int y )
- Avoids accidental changes {
declarations and statements,
calculations of x
▪ Call by reference return x; }
– Passes original argument
– Changes in function effect original
– Only used with trusted functions
▪ For now, we focus on call by value

 2007 Pearson Education, Inc. All rights reserved.

 43

5.10 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

 2007 Pearson Education, Inc. All rights reserved.

 44

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)

returns number between 1 and 6

 2007 Pearson Education, Inc. All rights reserved.

Computers
and Random Numbers

▪ Computers are “deterministic” machines

▪ Computers are not capable of true randomness
▪ Instead, pseudo-random numbers are used
– Pseudo-random numbers are generated using a
mathematical formula
– There is a pattern in pseudo-random numbers
– The pattern is nearly impossible to observe

 2007 Pearson Education, Inc. All rights reserved.

Advantage of Psuedo-Randomness

▪ It would be difficult to debug programs that use

truly random numbers (can’t recreate error cases
on demand)
▪ By providing the same start-value (seed) to the
generator, the same sequence results on each run
and error cases can be observed
▪ When you are through debugging, you can use a
different seed each time.
– Often, this is done by using the system clock

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.7: fig05_07.c 47
2 Shifted, scaled integers produced by 1 + rand() % 6 */
3 #include <stdio.h>
Outline
4 #include <stdlib.h>
5
6 /* function main begins program execution */
fig05_07.c
7 int main( void )
8 {
9 int i; /* counter */
10
11 /* loop 20 times */
12 for ( i = 1; i <= 20; i++ ) {
13
14 /* pick random number from 1 to 6 and output it */
15 printf( "%10d", 1 + ( rand() % 6 ) ); Generates a random number between 1 and 6
16
17 /* if counter is divisible by 5, begin new line of output */
18 if ( i % 5 == 0 ) {
19 printf( "\n" );
20 } /* end if */
21
22 } /* end for */
23
24 return 0; /* indicates successful termination */
25
26 } /* end main */
6 6 5 5 6
5 1 1 5 3
6 6 2 4 2
6 2 3 4 1

 2007 Pearson Education,

Inc. All rights reserved.
1 /* Fig. 5.8: fig05_08.c 48
2 Roll a six-sided die 6000 times */
3 #include <stdio.h>
Outline
4 #include <stdlib.h>
5
6 /* function main begins program execution */
fig05_08.c
7 int main( void )
8 {
9 int frequency1 = 0; /* rolled 1 counter */
(1 of 3 )
10 int frequency2 = 0; /* rolled 2 counter */
11 int frequency3 = 0; /* rolled 3 counter */
12 int frequency4 = 0; /* rolled 4 counter */
If you roll a six sided die 6000
13 int frequency5 = 0; /* rolled 5 counter */
times, how many times you get 1,
14 int frequency6 = 0; /* rolled 6 counter */
how many times you get 2 and so
15
on.. .
16 int roll; /* roll counter, value 1 to 6000 */
frequency1 variable is used to
17 int face; /* represents one roll of the die, value 1 to 6 */
count 1,
18
frequency2 variable is used to
19 /* loop 6000 times and summarize results */
count 2 …
20 for ( roll = 1; roll <= 6000; roll++ ) {
21 face = 1 + rand() % 6; /* random number from 1 to 6 */
22
23 /* determine face value and increment appropriate counter */
24 switch ( face ) {
25
26 case 1: /* rolled 1 */
27 ++frequency1;
28 break;
29

 2007 Pearson Education,

Inc. All rights reserved.
30 case 2: /* rolled 2 */ 49
31 ++frequency2;
32 break;
Outline
33
34 case 3: /* rolled 3 */
35 ++frequency3;
fig05_08.c
36 break;
37
38 case 4: /* rolled 4 */
(2 of 3 )
39 ++frequency4;
40 break;
41
42 case 5: /* rolled 5 */
43 ++frequency5;
44 break;
45
46 case 6: /* rolled 6 */
47 ++frequency6;
48 break; /* optional */
49 } /* end switch */
50
51 } /* end for */
52

 2007 Pearson Education,

Inc. All rights reserved.
53 /* display results in tabular format */ 50
54 printf( "%s%13s\n", "Face", "Frequency" );
55 printf( " 1%13d\n", frequency1 );
Outline
56 printf( " 2%13d\n", frequency2 );
57 printf( " 3%13d\n", frequency3 );
58 printf( " 4%13d\n", frequency4 );
fig05_08.c
59 printf( " 5%13d\n", frequency5 );
60 printf( " 6%13d\n", frequency6 );
61
(3 of 3 )
62 return 0; /* indicates successful termination */
63
64 } /* end main */

Face Frequency
1 1003
2 1017
3 983
4 994
5 1004
6 999

 2007 Pearson Education,

Inc. All rights reserved.
 51

rand() function returns same sequence for every

function call

srand function
– <stdlib.h>
– Takes an integer seed and jumps to that location in its
"random" sequence
srand( seed );

 2007 Pearson Education, Inc. All rights reserved.

 52

5.10 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 number of seconds that have passed since
January 1, 1970
“Randomizes" the seed

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.9: fig05_09.c 53
2 Randomizing die-rolling program */
3 #include <stdlib.h>
Outline
4 #include <stdio.h>
5
6 /* function main begins program execution */
fig05_09.c
7 int main( void )
8 {
9 int i; /* counter */
(1 of 2 )
10 unsigned seed; /* number used to seed random number generator */
11
12 printf( "Enter seed: " );
13 scanf( "%u", &seed ); /* note %u for unsigned */
14
15 srand( seed ); /* seed random number generator */ Seeds the rand function
16
17 /* loop 10 times */
18 for ( i = 1; i <= 10; i++ ) {
19

 2007 Pearson Education,

Inc. All rights reserved.
20 /* pick a random number from 1 to 6 and output it */ 54
21 printf( "%10d", 1 + ( rand() % 6 ) );
22
Outline
23 /* if counter is divisible by 5, begin a new line of output */
24 if ( i % 5 == 0 ) {
25 printf( "\n" );
fig05_09.c
26 } /* end if */
27
28 } /* end for */
(2 of 2 )
29
30 return 0; /* indicates successful termination */
31
32 } /* end main */

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

Enter seed: 67
6 1 4 6 2
1 6 1 6 4

 2007 Pearson Education,

Inc. All rights reserved.
Using Time to Seed the Generator

If you hard code the seed or allow the user to enter a seed,
simulated randomness is lost
Most programmers use the “time” function to seed the generator
This lessens the probability that a user can determine the pattern of
psuedo-random numbers

 2007 Pearson Education,

Inc. All rights reserved.
Using Time to Seed the Generator
Must include the <time.h> library
Provides function “time( )”

Calling function “time( )”:

time( NULL )
Returns the current time from the system clock
Expressed in number of seconds elapsed since 00:00 hours, Jan 1, 1970
UTC

srand( time( NULL );

 2007 Pearson Education,

Inc. All rights reserved.
 57

Common Programming Error 5.11

Using srand in place of rand to generate

random numbers.

 2007 Pearson Education, Inc. All rights reserved.

 58

5.11 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

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.10: fig05_10.c 59
2 Craps */
3 #include <stdio.h>
Outline
4 #include <stdlib.h>
5 #include <time.h> /* contains prototype for function time */
6
fig05_10.c
7 /* enumeration constants represent game status */
enum Status { CONTINUE, WON, LOST };
8
enum (enumeration) assigns
(1numerical
of 4 )
9
10 int rollDice( void ); /* function prototype */ values to CONTINUE, WON and LOST
11
12 /* function main begins program execution */
13 int main( void )
14 {
15 int sum; /* sum of rolled dice */
16 int myPoint; /* point earned */
17
18 enum Status gameStatus; /* can contain CONTINUE, WON, or LOST */
19
20 /* randomize random number generator using current time */
21 srand( time( NULL ) );
22
23 sum = rollDice(); /* first roll of the dice */
24
25 /* determine game status based on sum of dice */
26 switch( sum ) {
27

 2007 Pearson Education,

Inc. All rights reserved.
28 /* win on first roll */ 60
29 case 7:
30 case 11:
Outline
31 gameStatus = WON;
32 break;
33
fig05_10.c
34 /* lose on first roll */
35 case 2:
36 case 3:
(2 of 4 )
37 case 12:
38 gameStatus = LOST;
39 break;
40
41 /* remember point */
42 default:
43 gameStatus = CONTINUE;
44 myPoint = sum;
45 printf( "Point is %d\n", myPoint );
46 break; /* optional */
47 } /* end switch */
48

 2007 Pearson Education,

Inc. All rights reserved.
49 /* while game not complete */ 61
50 while ( gameStatus == CONTINUE ) {
51 sum = rollDice(); /* roll dice again */
Outline
52
53 /* determine game status */
54 if ( sum == myPoint ) { /* win by making point */
fig05_10.c
55 gameStatus = WON; /* game over, player won */
56 } /* end if */
57 else {
(3 of 4 )
58
59 if ( sum == 7 ) { /* lose by rolling 7 */
60 gameStatus = LOST; /* game over, player lost */
61 } /* end if */
62
63 } /* end else */
64
65 } /* end while */
66
67 /* display won or lost message */
68 if ( gameStatus == WON ) { /* did player win? */
69 printf( "Player wins\n" );
70 } /* end if */
71 else { /* player lost */
72 printf( "Player loses\n" );
73 } /* end else */
74
75 return 0; /* indicates successful termination */
76
77 } /* end main */

 2007 Pearson Education,

Inc. All rights reserved.
78 62
79 /* roll dice, calculate sum and display results */
80 int rollDice( void )
Outline
81 {
82 int die1; /* first die */
83 int die2; /* second die */
fig05_10.c
84 int workSum; /* sum of dice */
85
86 die1 = 1 + ( rand() % 6 ); /* pick random die1 value */
(4 of 4 )
87 die2 = 1 + ( rand() % 6 ); /* pick random die2 value */
88 workSum = die1 + die2; /* sum die1 and die2 */
89
90 /* display results of this roll */
91 printf( "Player rolled %d + %d = %d\n", die1, die2, workSum );
92
93 return workSum; /* return sum of dice */
94
95 } /* end function rollRice */

 2007 Pearson Education,

Inc. All rights reserved.
Player rolled 5 + 6 = 11 63
Player wins Outline

Player rolled 4 + 1 = 5
Point is 5
Player rolled 6 + 2 = 8 fig05_11.c
Player rolled 2 + 1 = 3
Player rolled 3 + 2 = 5
Player wins

Player rolled 1 + 1 = 2
Player loses

Player rolled 6 + 4 = 10
Point is 10
Player rolled 3 + 4 = 7
Player loses

 2007 Pearson Education,

Inc. All rights reserved.
 64

Common Programming Error 5.12

Assigning a value to an enumeration constant after it
has been defined is a syntax error.

 2007 Pearson Education, Inc. All rights reserved.

 65

Good Programming Practice 5.9

Use only uppercase letters in the names of enumeration
constants to make these constants stand out in a
program and to indicate that enumeration constants are
not variables.

 2007 Pearson Education, Inc. All rights reserved.

 66

5.12 Storage Classes

Every variable in C programming has two properties: type and
storage class.

Storage class determines the scope and lifetime of a variable.

 2007 Pearson Education, Inc. All rights reserved.

 67

Local Variable
The variables declared inside the function are automatic or local variables.

The local variables exist only inside the function in which it is declared. When the
function exits, the local variables are destroyed.

int main() {
int n; // n is a local variable to main() function
... .. ...
}

void func() {
int n1; // n1 is local to func() function
}

In the above code, n1 is destroyed when func() exits. Likewise, n gets destroyed
when main() exits.

 2007 Pearson Education, Inc. All rights reserved.

 68

Global Variable
Variables that are declared outside of all functions are known as global variables.
Global variables are accessible to any function.

#include <stdio.h>
void display();
int n = 5; // global variable

int main() {
++n; // variable n is not declared in the main() function
display();
return 0;}

void display() {
++n; // variable n is not declared in the display() function
printf ("n = %d", n); }

 2007 Pearson Education, Inc. All rights reserved.

 69

▪ Automatic storage
– Object created and destroyed within its block
– Automatic storage is default for local variables
auto double x, y;
Or
double x,y
Automatic storage is a means of conserving memory,
because automatic variables exist only when they are
needed. They are created when the function in which they
are defined is entered and they are destroyed when the
function is exited.

 2007 Pearson Education, Inc. All rights reserved.

 70

▪ Static storage
– Variables exist for entire program execution
– Default value is zero

The static storage class instructs the compiler to keep a

local variable in existence during the life-time of the
program instead of creating and destroying it each time it
comes into and goes out of scope.

Therefore, making local variables static allows them to

maintain their values between function calls.

 2007 Pearson Education, Inc. All rights reserved.

 71

5.13 Scope Rules

▪ File scope
– Identifier defined outside function, known in all functions
– Used for global variables, function definitions, function
prototypes
▪ Block scope
– Identifier declared inside a block
- Block scope begins at definition, 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

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.12: fig05_12.c 72
2 A scoping example */
3 #include <stdio.h>
Outline
4
5 void useLocal( void ); /* function prototype */
6 void useStaticLocal( void ); /* function prototype */
fig05_12.c
7 void useGlobal( void ); /* function prototype */
8
9 int x = 1; /* global variable */
(1 of 4 )
10
Global variable with file scope
11 /* function main begins program execution */
12 int main( void )
13 {
14 int x = 5; /* local variable to main */ Variable with block scope
15
16 printf("local x in outer scope of main is %d\n", x );
17
18 { /* start new scope */
19 int x = 7; /* local variable to new scope */ Variable with block scope
20
21 printf( "local x in inner scope of main is %d\n", x );
22 } /* end new scope */
23

 2007 Pearson Education,

Inc. All rights reserved.
24 printf( "local x in outer scope of main is %d\n", x ); 73
25
26 useLocal(); /* useLocal has automatic local x */
Outline
27 useStaticLocal(); /* useStaticLocal has static local x */
28 useGlobal(); /* useGlobal uses global x */
29 useLocal(); /* useLocal reinitializes automatic local x */
fig05_12.c
30 useStaticLocal(); /* static local x retains its prior value */
31 useGlobal(); /* global x also retains its value */
32
(2 of 4 )
33 printf( "\nlocal x in main is %d\n", x );
34
35 return 0; /* indicates successful termination */
36
37 } /* end main */
38
39 /* useLocal reinitializes local variable x during each call */
40 void useLocal( void )
41 {
42 int x = 25; /* initialized each time useLocal is called */
Variable with block scope
43
44 printf( "\nlocal x in useLocal is %d after entering useLocal\n", x );
45 x++;
46 printf( "local x in useLocal is %d before exiting useLocal\n", x );
47 } /* end function useLocal */
48

 2007 Pearson Education,

Inc. All rights reserved.
49 /* useStaticLocal initializes static local variable x only the first time 74
50 the function is called; value of x is saved between calls to this
51 function */
Outline
52 void useStaticLocal( void )
53 {
54 /* initialized only first time useStaticLocal is called */
fig05_12.c
55 static int x = 50;
56
Static variable with block scope
57 printf( "\nlocal static x is %d on entering useStaticLocal\n", x );
(3 of 4 )
58 x++;
59 printf( "local static x is %d on exiting useStaticLocal\n", x );
60 } /* end function useStaticLocal */
61
62 /* function useGlobal modifies global variable x during each call */
63 void useGlobal( void )
64 {
65 printf( "\nglobal x is %d on entering useGlobal\n", x );
66 x *= 10; Global variable
67 printf( "global x is %d on exiting useGlobal\n", x );
68 } /* end function useGlobal */

 2007 Pearson Education,

Inc. All rights reserved.
 75
local x in outer scope of main is 5
local x in inner scope of main is 7 Outline
local x in outer scope of main is 5

local x in useLocal is 25 after entering useLocal

local x in useLocal is 26 before exiting useLocal
fig05_12.c
local static x is 50 on entering useStaticLocal
local static x is 51 on exiting useStaticLocal
(4 of 4 )
global x is 1 on entering useGlobal
global x is 10 on exiting useGlobal

local x in useLocal is 25 after entering useLocal

local x in useLocal is 26 before exiting useLocal

local static x is 51 on entering useStaticLocal

local static x is 52 on exiting useStaticLocal

global x is 10 on entering useGlobal

global x is 100 on exiting useGlobal

local x in main is 5

 2007 Pearson Education,

Inc. All rights reserved.
 76

5.14 Recursion
▪ Recursive functions
– Functions that call themselves.The function launches a new copy of itself
(recursion step) to solve what it cannot do

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;

Fig. 5.13 | Recursive evaluation of 5!.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.14: fig05_14.c 77
2 Recursive factorial function */
3 #include <stdio.h>
Outline
4
5 long factorial( long number ); /* function prototype */
6
fig05_14.c
7 /* function main begins program execution */
8 int main( void )
9 {
(1 of 2 )
10 int i; /* counter */
11
12 /* loop 11 times; during each iteration, calculate
13 factorial( i ) and display result */
14 for ( i = 0; i <= 10; i++ ) {
15 printf( "%2d! = %ld\n", i, factorial( i ) );
16 } /* end for */
17
18 return 0; /* indicates successful termination */
19
20 } /* end main */
21

 2007 Pearson Education,

Inc. All rights reserved.
22 /* recursive definition of function factorial */ 78
23 long factorial( long number )
24 {
Outline
25 /* base case */
26 if ( number <= 1 ) {
27 return 1;
fig05_14.c
28 } /* end if */
29 else { /* recursive step */
30 return ( number * factorial( number - 1 ) );
(2 of 2 )
31 } /* end else */
32
33 } /* end function factorial */

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800

 2007 Pearson Education,

Inc. All rights reserved.
 79

Common Programming Error 5.16

Either omitting the base case, or writing the recursion
step incorrectly so that it does not converge on the
base case, will cause infinite recursion, eventually
exhausting memory.

This is analogous to the problem of an infinite loop in

an iterative (nonrecursive) solution. Infinite recursion
can also be caused by providing an unexpected input.

 2007 Pearson Education, Inc. All rights reserved.

 80

5.15 Example Using Recursion:

Fibonacci Series
▪ Fibonacci series: 0, 1, 1, 2, 3, 5, 8...
– Each number is the sum of the previous two
– Can be solved recursively:
- fib( n ) = fib( n - 1 ) + fib( n – 2 )
– Code for the fibonacci function
long fibonacci( long n )
{
if (n == 0 || n == 1) // base case
return n;
else
return fibonacci( n - 1) +
fibonacci( n – 2 );
}

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 5.15: fig05_15.c 81
2 Recursive fibonacci function */
3 #include <stdio.h>
Outline
4
5 long fibonacci( long n ); /* function prototype */
6
fig05_15.c
7 /* function main begins program execution */
8 int main( void )
9 {
(1 of 4 )
10 long result; /* fibonacci value */
11 long number; /* number input by user */
12
13 /* obtain integer from user */
14 printf( "Enter an integer: " );
15 scanf( "%ld", &number );
16
17 /* calculate fibonacci value for number input by user */
18 result = fibonacci( number );
19
20 /* display result */
21 printf( "Fibonacci( %ld ) = %ld\n", number, result );
22
23 return 0; /* indicates successful termination */
24
25 } /* end main */
26

 2007 Pearson Education,

Inc. All rights reserved.
27 /* Recursive definition of function fibonacci */ 82
28 long fibonacci( long n )
29 {
Outline
30 /* base case */
31 if ( n == 0 || n == 1 ) {
32 return n;
fig05_15.c
33 } /* end if */
34 else { /* recursive step */
35 return fibonacci( n - 1 ) + fibonacci( n - 2 );
(2 of 4 )
36 } /* end else */
37
38 } /* end function fibonacci */

Enter an integer: 0
Fibonacci( 0 ) = 0

Enter an integer: 1
Fibonacci( 1 ) = 1

Enter an integer: 2
Fibonacci( 2 ) = 1
(continued on next slide… )

 2007 Pearson Education,

Inc. All rights reserved.
 (continued from previous slide…) 83
Enter an integer: 3
Fibonacci( 3 ) = 2
Outline

Enter an integer: 4
Fibonacci( 4 ) = 3 fig05_15.c

(3 of 4 )
Enter an integer: 5
Fibonacci( 5 ) = 5

Enter an integer: 6
Fibonacci( 6 ) = 8
(continued on next slide… )

 2007 Pearson Education,

Inc. All rights reserved.
 (continued from previous slide…) 84
Enter an integer: 10
Fibonacci( 10 ) = 55
Outline

Enter an integer: 20
Fibonacci( 20 ) = 6765 fig05_15.c

(4 of 4 )
Enter an integer: 30
Fibonacci( 30 ) = 832040

Enter an integer: 35
Fibonacci( 35 ) = 9227465

 2007 Pearson Education,

Inc. All rights reserved.
 85

Fig. 5.16 | Set of recursive calls for fibonacci(3).

 2007 Pearson Education, Inc. All rights reserved.

 86

5.16 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)

 2007 Pearson Education, Inc. All rights reserved.

 87

Software Engineering Observation 5.13

Any problem that can be solved recursively can also

be solved iteratively (nonrecursively).
A recursive approach is normally chosen in
preference to an iterative approach when the
recursive approach more naturally mirrors the
problem and results in a program that is easier to
understand and debug.
Another reason to choose a recursive solution is that
an iterative solution may not be apparent.

 2007 Pearson Education, Inc. All rights reserved.

 88

Performance Tip 5.5

Avoid using recursion in performance situations.
Recursive calls take time and consume additional
memory.

 2007 Pearson Education, Inc. All rights reserved.

 89

Performance Tip 5.6

Functionalizing programs in a neat, hierarchical
manner promotes good software engineering. But it
has a price. A heavily functionalized program—as
compared to a monolithic (i.e., one-piece) program
without functions—makes potentially large numbers
of function calls, and these consume execution time on
a computer’s processor(s). So, although monolithic
programs may perform better, they are more difficult
to program, test, debug, maintain, and evolve.

 2007 Pearson Education, Inc. All rights reserved.