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
2000 Prentice Hall, Inc. All rights reserved.

5.1

Introduction

Divide and conquer

Construct a program from smaller pieces or

components
Each piece more manageable than the original program

2000 Prentice Hall, Inc. All rights reserved.

5.2

Program Modules in C

Functions
Modules in C
Programs written by combining user-defined functions with
library functions

C standard library has a wide variety of functions

Makes programmer's job easier - avoid reinventing the wheel

2000 Prentice Hall, Inc. All rights reserved.

5.2

Program Modules in C (II)

Function calls
Invoking functions
Provide function name and arguments (data)
Function performs operations or manipulations
Function returns results

Boss asks worker to complete task

Worker gets information, does task, returns result

Information hiding: boss does not know details

2000 Prentice Hall, Inc. All rights reserved.

5.3

Math Library Functions

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( 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

2000 Prentice Hall, Inc. All rights reserved.

5.4

Functions

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
Divide and conquer
Manageable program development

Software reusability
Use existing functions as building blocks for new programs
Abstraction - hide internal details (library functions)

Avoids code repetition

2000 Prentice Hall, Inc. All rights reserved.

5.5

Function Definitions

Functiondefinitionformat
returnvaluetypefunctionname( parameterlist )
{
declarationsandstatements
}

Function-name: any valid identifier

Return-value-type: data type of the result (default int)
void - function returns nothing

Parameter-list: comma separated list, declares parameters (default

int)

2000 Prentice Hall, Inc. All rights reserved.

5.5

Function Definitions (II)

Functiondefinitionformat(continued)
returnvaluetypefunctionname( parameterlist )
{
declarationsandstatements
}

Declarations and statements: function body (block)

Variables can be declared inside blocks (can be nested)
Function can not be defined inside another function
Returning control
If nothing returned
return;
or, until reaches right brace
If something returned
return expression;
2000 Prentice Hall, Inc. All rights reserved.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/* Fig. 5.4: fig05_04.c

Finding the maximum of three integers */
#include <stdio.h>
int maximum( int, int, int );

/* function prototype */

int main()
{
int a, b, c;
printf( "Enter three integers: " );
scanf( "%d%d%d", &a, &b, &c );
printf( "Maximum is: %d\n", maximum( a, b, c ) );
return 0;
}
/* Function maximum definition */
int maximum( int x, int y, int z )
{
int max = x;
if ( y > max )
max = y;
if ( z > max )
max = z;
return max;
}

Enter three integers: 22 85 17

Maximum is: 85
2000 Prentice Hall, Inc. All rights reserved.

Outline
1. Function prototype
(3 parameters)
2. Input values
2.1 Call function
3. Function definition

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
int maximum( int, int, int );
Takes in 3 ints
Returns an int

Promotion rules and conversions

Converting to lower types can lead to errors

2000 Prentice Hall, Inc. All rights reserved.

5.7

Header Files

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

2000 Prentice Hall, Inc. All rights reserved.

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

2000 Prentice Hall, Inc. All rights reserved.

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
2000 Prentice Hall, Inc. All rights reserved.

5.9

Random Number Generation (II)

srand function
<stdlib.h>
Takes an integer seed - jumps to location in "random" sequence
srand( seed );
srand( time( NULL ) ); //load <time.h>

time( NULL )- time program was compiled in seconds

"randomizes" the seed

2000 Prentice Hall, Inc. All rights reserved.

/* Fig. 5.9: fig05_09.c

Randomizing die-rolling program */

#include <stdlib.h>

#include <stdio.h>

5
6

int main()

int i;

unsigned seed;

10
11

printf( "Enter seed: " );

12

scanf( "%u", &seed );

13

srand( seed );

14
15

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

16

printf( "%10d", 1 + ( rand() % 6 ) );

17
18

if ( i % 5 == 0 )

19
20

printf( "\n" );
}

21
22

return 0;

23 } 2000 Prentice Hall, Inc. All rights reserved.

Outline
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

Enter seed: 67
6
1

1
6

4
1

6
6

2
4

Enter seed: 867

2
1

4
1

6
3

1
6

6
2

Enter seed: 67
6
1

1
6

4
1

6
6

2
4

2000 Prentice Hall, Inc. All rights reserved.

Outline
Program Output

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

2000 Prentice Hall, Inc. All rights reserved.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/* Fig. 5.10: fig05_10.c

Craps */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

Outline
1. rollDice
prototype

int rollDice( void );

int main()
{
int gameStatus, sum, myPoint;
srand( time( NULL ) );
sum = rollDice();

1.1 Initialize variables

1.2 Seed srand
/* first roll of the dice */

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;
}
while ( gameStatus == 0 ) {
sum = rollDice();
2000 Prentice Hall, Inc. All rights reserved.

/* keep rolling */

2. Define switch
statement for
win/loss/continue
2.1 Loop

33

if ( sum == myPoint )

34

gameStatus = 1;

35

if ( sum == 7 )

37

/* lose by rolling 7 */

gameStatus = 2;

2.2 Print win/loss

39
40
41
42
43

Outline

else

36
38

/* win by making point */

if ( gameStatus == 1 )
printf( "Player wins\n" );
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 }
Player rolled 6 + 5 = 11
Player wins
2000 Prentice Hall, Inc. All rights reserved.

Program Output

Player rolled 6 + 6 = 12
Player loses

Player rolled
Point is 10
Player rolled
Player rolled
Player rolled
Player rolled
Player wins

4 + 6 = 10

Player rolled
Point is 4
Player rolled
Player rolled
Player rolled
Player rolled
Player rolled
Player rolled
Player loses

1 + 3 = 4

2
6
3
6

1
5
4
6
1
5

+
+
+
+

+
+
+
+
+
+

4
5
3
4

4
4
6
3
2
2

=
=
=
=

=
=
=
=
=
=

6
11
6
10

5
9
10
9
3
7

2000 Prentice Hall, Inc. All rights reserved.

Outline
Program Output

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 - what files 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: triestoputvariableintohighspeedregisters

Canonlybeusedforautomaticvariables
register int counter = 1;

2000 Prentice Hall, Inc. All rights reserved.

5.11 Storage Classes (II)

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

2000 Prentice Hall, Inc. All rights reserved.

5.12 Scope Rules

File scope
Identifier defined outside function, known in all functions
Global variables, function definitions, function prototypes

Function scope

Can only be referenced inside a function body

Only labels (start: case: , etc.)

2000 Prentice Hall, Inc. All rights reserved.

5.12 Scope Rules (II)

Block scope
Identifier declared inside a block
Block scope begins at declaration, ends at right brace

Variables, function parameters (local variables of function)

Outer blocks "hidden" from inner blocks if same variable
name

Function prototype scope

Identifiers in parameter list

Names in function prototype optional, and can be used
anywhere

2000 Prentice Hall, Inc. All rights reserved.

1
2
3

/* Fig. 5.12: fig05_12.c

A scoping example */
#include <stdio.h>

4
5
6
7

void a( void );
void b( void );
void c( void );

/* function prototype */
/* function prototype */
/* function prototype */

8
9 int x = 1;
10
11 int main()
12 {
13
14
15
16
17
18
19
20

int x = 5;

/* local variable to main */

printf("local x in outer scope of main is %d\n", x );

{

/* start new scope */

int x = 7;

1. Function prototypes
1.1 Initialize global
variable
1.2 Initialize local
variable
1.3 Initialize local
variable in block
2. Call functions

printf( "local x in inner scope of main is %d\n", x );

21
22
23
24

25
26
27
28

a();
b();
c();
a();

29
30

/* global variable */

Outline

/* end new scope */

printf( "local x in outer scope of main is %d\n", x );

/*
/*
/*
/*

a
b
c
a

has automatic local x */

has static local x */
uses global x */
reinitializes automatic local x */

b();
/* static local x retains its previous value */
2000
Prentice Hall, Inc.
rights reserved.
c();
/* All
global
x also retains its value */

3. Output results

31
32

printf( "local x in main is %d\n", x );

33

return 0;

Outline

34 }

3.1 Function definitions

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

41

++x;

42

printf( "local x in a is %d before exiting a\n", x );

43 }
44
45 void b( void )
46 {
47

static int x = 50;

48

/* static initialization only */

/* first time b is called */

49

printf( "\nlocal static x is %d on entering b\n", x );

50

++x;

51

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 } 2000 Prentice Hall, Inc. All rights reserved.

local x in outer scope of main is 5

local x in inner scope of main is 7
local x in outer scope of main is 5
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 x in a is 25 after entering a
local x in a is 26 before exiting a
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

2000 Prentice Hall, Inc. All rights reserved.

Outline
Program Output

5.13 Recursion
Recursive functions
Function that calls itself
Can only solve a base case
Divides up problem into
What it can do
What it cannot do - resembles original problem
Launches a new copy of itself (recursion step)

Eventually base case gets solved

Gets plugged in, works its way up and solves whole problem

2000 Prentice Hall, Inc. All rights reserved.

5.13 Recursion (II)

Example: factorial:
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;

2000 Prentice Hall, Inc. All rights reserved.

5.14 Example Using Recursion: The

Fibonacci Series
Fibonacci series: 0, 1, 1, 2, 3, 5, 8...
Each number sum of the previous two
fib(n) = fib(n-1) + fib(n-2) - recursive formula

long fibonacci(long n)
{
if (n==0 || n==1) //base case
return n;
else return fibonacci(n-1) + fibonacci(n-2);
}

2000 Prentice Hall, Inc. All rights reserved.

5.14 Example Using Recursion: The

Fibonacci Series (II)
f( 3 )

return

return

f( 1 )

return 1

2000 Prentice Hall, Inc. All rights reserved.

f( 2 )

f( 0 )

return 0

f( 1 )

return 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/* Fig. 5.15: fig05_15.c

Recursive fibonacci function */
#include <stdio.h>
long fibonacci( long );
int main()
{
long result, number;
printf( "Enter an integer: " );
scanf( "%ld", &number );
result = fibonacci( number );
printf( "Fibonacci( %ld ) = %ld\n", number, result );
return 0;
}
/* Recursive definition of function fibonacci */
long fibonacci( long n )
{
if ( n == 0 || n == 1 )
return n;
else
return fibonacci( n - 1 ) + fibonacci( n - 2 );
}

Enter an integer: 0
Fibonacci(0) = 0
Enter an integer: 1
Fibonacci(1) = 1
2000 Prentice Hall, Inc. All rights reserved.

Outline
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: 2
Fibonacci(2) = 1

Outline

Enter an integer: 3
Fibonacci(3) = 2
Enter an integer: 4
Fibonacci(4) = 3
Enter an integer: 5
Fibonacci(5) = 5
Enter an integer: 6
Fibonacci(6) = 8
Enter an integer: 10
Fibonacci(10) = 55
Enter an integer: 20
Fibonacci(20) = 6765
Enter an integer: 30
Fibonacci(30) = 832040
Enter an integer: 35
Fibonacci(35) = 9227465

2000 Prentice Hall, Inc. All rights reserved.

Program Output

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)

2000 Prentice Hall, Inc. All rights reserved.