Chapter 6 Functions

About This Presentation

Title:

Chapter 6 Functions

Description:

... Out with C , 3rd Edition. 6.1 Focus on Software Engineering: ... cout 'I am now inside the function first.n'; 12. Starting Out with C , 3rd Edition ... – PowerPoint PPT presentation

Number of Views:28

Avg rating:3.0/5.0

Slides: 133

Provided by: cwy774

Category:

more less

Transcript and Presenter's Notes

Title: Chapter 6 Functions

1
Chapter 6 Functions
2
6.1 Focus on Software Engineering Breaking Up
Your Programs

Programs may be broken up into many manageable
functions.

3
6.2 Defining and Calling Functions

A function call is a statement that causes a
function to execute. A function definition
contains the statements that make up the
function.
The line in the definition that reads void
main(void) is called the function header.

4
Figure 6-1
5
Calling a Function

Function Header
void displayMessage()
Function Call
displayMessage()

6
Program 6-1

include ltiostream.hgt
//
// Definition of function displayMessage.
// This function displays a greeting.
//
void displayMessage()
cout ltlt "Hello from the function
displayMessage.\n"
void main(void)
cout ltlt "Hello from main.\n"
displayMessage()
cout ltlt "Back in function main again.\n"

7
Program Output

Hello from main.
Hello from the function displayMessage.
Back in function main again.

8
Figure 6-2
void displayMessage() cout ltlt Hello from the
function displayMessage.\n
void main(void) cout ltlt Hello from
main.\n displayMessage() cout ltlt Back in
function main again.\n
9
Program 6-2

//The function displayMessage is repeatedly
called from a loop
include ltiostream.hgt
//
// Definition of function displayMessage.
// This function displays a greeting.
//
void displayMessage()
cout ltlt "Hello from the function
displayMessage.\n"
void main(void)
cout ltlt "Hello from main.\n"
for (int count 0 count lt 5 count)
displayMessage() // Call displayMessage
cout ltlt "Back in function main again.\n"

10
Program Output

Hello from main.
Hello from the function displayMessage.
Hello from the function displayMessage.
Hello from the function displayMessage.
Hello from the function displayMessage.
Hello from the function displayMessage.
Back in function main again.

11
Program 6-3

// This program has three functions main, first,
and second.
include ltiostream.hgt
//
// Definition of function first.
// This function displays a message.
//
void first(void)
cout ltlt "I am now inside the function first.\n"

12
Program continues

//
// Definition of function second.
// This function displays a message.
//
void second(void)
cout ltlt "I am now inside the function
second.\n"
void main(void)
cout ltlt "I am starting in function main.\n"
first() // Call function first
second() // Call function second
cout ltlt "Back in function main again.\n"

13
Program Output

I am starting in function main.
I am now inside the function first.
I am now inside the function second.
Back in function main again.

14
Figure 6-3
void first(void) cout ltlt I am now inside
function first.\n
void second(void) cout ltlt I am now inside
function second.\n
void main(void) cout ltlt I am starting in
function main.\n first() second()
cout ltlt Back in function main again.\n
15
Program 6-4

// This program has three functions main, deep,
and deeper
include ltiostream.hgt
//
// Definition of function deeper.
// This function displays a message.
//
void deeper(void)
cout ltlt "I am now inside the function
deeper.\n"

16
Program continues

//
// Definition of function deep.
// This function displays a message.
//
void deep()
cout ltlt "I am now inside the function deep.\n"
deeper() // Call function deeper
cout ltlt "Now I am back in deep.\n"
void main(void)
cout ltlt "I am starting in function main.\n"
deep() // Call function deep
cout ltlt "Back in function main again.\n"

17
Program Output

I am starting in function main.
I am now inside the function deep.
I am now inside the function deeper.
Now I am back in deep.
Back in function main again.

18
Figure 6-4
void deep(void) cout ltlt I am now inside
function deep.\n deeper() cout ltlt Now I
am back in deep.\n
void deeper(void) cout ltlt I am now inside
function deeper.\n
void main(void) cout ltlt I am starting in
function main.\n deep() cout ltlt Back in
function main again.\n
19
6.3 Function Prototypes

A function prototype eliminates the need to place
a function definition before all calls to the
function.
Here is a prototype for the displayMessage
function in Program 6-1void displayMessage(void)

20
Program 6-5

// This program has three functions main, first,
and second.
include ltiostream.hgt
// Function Prototypes
void first(void)
void second(void)
void main(void)
cout ltlt "I am starting in function main.\n"
first() // Call function first
second() // Call function second
cout ltlt Back in function main again.\n"
Program Continues on next slide

21
Program 6-5 Continues

// Definition of function first.
// This function displays a message.
void first(void)
cout ltlt I am now inside the function
first.\n
// Definition of function second
// This function displays a message.
void second(void)
cout ltlt I am now inside the function
second.\n

22
Program 6-5 Output

I am starting in function main.
I am now inside the function first.
I am now inside the function second.
Back in function main again.

23
6.4 Sending Information Into a Function

When a function is called, the program may send
values (arguments) into the function.
Arguments are passed into parameters.void
displayValue(int num) cout ltlt The value is
ltlt num ltlt endl

24
Program 6-6

// This program demonstrates a function with a
parameter.
include ltiostream.hgt
// Function Prototype
void displayValue(int)
void main(void)
cout ltlt "I am passing 5 to displayValue.\n"
displayValue(5) //Call displayValue with
argument 5
cout ltlt "Now I am back in main.\n"
Program Continues to next slide

25
Program 6-6

//
// Definition of function displayValue.
// It uses an integer parameter whose value is
displayed.
//
void displayValue(int num)
cout ltlt The value is ltlt num ltlt endl

26
Program Output

I am passing 5 to displayValue.
The value is 5
Now I am back in main.

27
Figure 6-5
displayValue(5)
void displayValue(int num) cout ltlt The
value is ltlt num ltlt endl
28
Program 6-7

// This program demonstrates a function with a
parameter.
include ltiostream.hgt
// Function Prototype
void displayValue(int)
void main(void)
cout ltlt "I am passing several values to
displayValue.\n"
displayValue(5) // Call displayValue with
argument 5
displayValue(10) // Call displayValue with
argument 10
displayValue(2) // Call displayValue with
argument 2
displayValue(16) // Call displayValue with
argument 16
cout ltlt "Now I am back in main.\n"
Program continues on next slide

29
Program 6-7 Continued

//
// Definition of function displayValue.
// It uses an integer parameter whose value is
displayed.
//
void displayValue(int num)
cout ltlt "The value is " ltlt num ltlt endl

30
Program Output

I am passing several values to displayValue.
The value is 5
The value is 10
The value is 2
The value is 16
Now I am back in main.

31
Program 6-8

// This program demonstrates a function with
three parameters.
include ltiostream.hgt
// Function prototype
void showSum(int, int, int)
void main(void)
int value1, value2, value3
cout ltlt "Enter three integers and I will
display "
cout ltlt "their sum "
cin gtgt value1 gtgt value2 gtgt value3
showSum(value1, value2, value3) // Call showSum
with // 3
arguments

32
Program continues

//
// Definition of function showSum.
// It uses three integer parameters. Their sum is
displayed.
//
void showSum(int num1, int num2, int num3)
cout ltlt (num1 num2 num3) ltlt endl

33
Program Output with Example Input

Enter three integers and I will display their
sum 4 8 7 Enter
19

34
Figure 6-6
showSum(value1, value2, value3)
void showSum(int num1, int num2, int num3)
cout ltlt num1 num2 num3 ltlt endl
35
6.5 Changing the value of a Parameter

When an argument is passed into a parameter, only
a copy of the arguments value is passed.
Changes to the parameter do not affect the
original argument. This is called passed by
value.

36
Program 6-9

// This program demonstrates that changes to a
function parameter
// have no effect on the original argument.
include ltiostream.hgt
// Function Prototype
void changeThem(int, float)
void main(void)
int whole 12
float real 3.5
cout ltlt "In main the value of whole is " ltlt
whole ltlt endl
cout ltlt "and the value of real is " ltlt real ltlt
endl
changeThem(whole, real) // Call changeThem with
2 arguments
cout ltlt "Now back in main again, the value of "
cout ltlt "whole is " ltlt whole ltlt endl
cout ltlt "and the value of real is " ltlt real ltlt
endl

37
Program continues

//
// Definition of function changeThem.
// It uses i, an int parameter, and f, a float.
The values of
// i and f are changed and then displayed.
//
void changeThem(int i, float f)
i 100
f 27.5
cout ltlt "In changeThem the value of i is changed
to "
cout ltlt i ltlt endl
cout ltlt "and the value of f is changed to " ltlt f
ltlt endl

38
Program Output

In main the value of whole is 12
and the value of real is 3.5
In changeThem the value of i is changed to 100
and the value of f is changed to 27.5
Now back in main again, the value of whole is 12
and the value of real is 3.5

39
Figure 6-7
40
6.6 Focus on Software Engineering Using
Functions in a Menu-Driven Program

Functions are ideal for use in menu-driven
programs. When the user selects an item from a
menu, the program can call the appropriate
function.

41
Program 6-10

// This is a menu-driven program that makes a
function call
// for each selection the user makes.
include ltiostream.hgt
// Function Prototypes
void adult(int)
void child(int)
void senior(int)
void main(void)
int choice, months

42
Program continues

cout.setf(iosfixed iosshowpoint)
cout.precision(2)
do
cout ltlt "\n\t\tHealth Club Membership
Menu\n\n"
cout ltlt "1. Standard adult Membership\n"
cout ltlt "2. child Membership\n"
cout ltlt "3. senior Citizen Membership\n"
cout ltlt "4. Quit the Program\n\n"
cout ltlt "Enter your choice "
cin gtgt choice

43
Program continues

if (choice ! 4)
cout ltlt "For how many months? "
cin gtgt months
switch (choice)
case 1 adult(months)
break
case 2 child(months)
break
case 3 senior(months)
break
case 4 cout ltlt "Thanks for using this "
cout ltlt "program.\n"
break

44
Program continues

default cout ltlt "The valid choices are 1-4.
"
cout ltlt "Try again.\n"
while (choice ! 4)
//
// Definition of function adult. Uses an integer
parameter, mon.
// mon holds the number of months the membership
should be
// calculated for. The cost of an adult
membership for that many
// months is displayed.
//
void adult(int mon)
cout ltlt "The total charges are "
cout ltlt (mon 40.0) ltlt endl

45
Program continues

//
// Definition of function child. Uses an integer
parameter, mon.
// mon holds the number of months the membership
should be
// calculated for. The cost of a child membership
for that many
// months is displayed.
//
void child(int mon)
cout ltlt "The total charges are "
cout ltlt (mon 20.0) ltlt endl

46
Program continues

//
// Definition of function senior. Uses an integer
parameter, mon.
// mon holds the number of months the membership
should be
// calculated for. The cost of a senior citizen
membership for
// that many months is displayed.
//
void senior(int mon)
cout ltlt "The total charges are "
cout ltlt (mon 30.0) ltlt endl

47
Program Output with Example Input

Health Club Membership Menu
1. Standard adult Membership
2. child Membership
3. senior Citizen Membership
4. Quit the Program
Enter your choice 1
For how many months 12
The total charges are 480.00
Health Club Membership Menu
1. Standard adult Membership
2. child Membership
3. senior Citizen Membership
4. Quit the Program
Enter your choice 4
Thanks for using this program.

48
6.7 The return Statement

The return statement causes a function to end
immediately.

49
Program 6-11

// This program demonstrates a function with a
return statement.
include ltiostream.hgt
// Function prototype
void halfway(void)
void main(void)
cout ltlt "In main, calling halfway...\n"
halfway()
cout ltlt "Now back in main.\n"

50
Program continues

//
// Definition of function halfway.
// This function has a return statement that
forces it to
// terminate before the last statement is
executed.
//
void halfway(void)
cout ltlt "In halfway now.\n"
return
cout ltlt"Will you ever see this message?\n"

51
Program Output

In main, calling halfway...
In halfway now.
Now back in main.

52
Program 6-12

// This program uses a function to perform
division. If division
// by zero is detected, the function returns.
include ltiostream.hgt
// Function prototype.
void divide(float, float)
void main(void)
float num1, num2
cout ltlt "Enter two numbers and I will divide the
first\n"
cout ltlt "number by the second number "
cin gtgt num1 gtgt num2
divide(num1, num2)

53
Program continues

//
// Definition of function divide.
// Uses two parameters arg1 and arg2. The
function divides arg1
// by arg2 and shows the result. If arg2 is zero,
however, the
// function returns.
//
void divide(float arg1, float arg2)
if (arg2 0.0)
cout ltlt "Sorry, I cannot divide by zero.\n"
return
cout ltlt "The quotient is " ltlt (arg1 / arg2) ltlt
endl

54
Program Output with Example Input

Enter two numbers and I will divide the first
number by the second number 12 0 Enter
Sorry, I cannot divide by zero.

55
6.8 Returning a value From a Function

A function may send a value back to the part of
the program that called the function.

56
Figure 6-10
57
Program 6-13

// This program uses a function that returns a
value.
include ltiostream.hgt
//Function prototype
int square(int)
void main(void)
int value, result
cout ltlt "Enter a number and I will square it "
cin gtgt value
result square(value)
cout ltlt value ltlt " squared is " ltlt result ltlt
endl

58
Program continues

//
// Definition of function square.
// This function accepts an int argument and
returns
// the square of the argument as an int.
//
int square(int number)
return number number

59
Program Output with Example Input

Enter a number and I will square it 20 Enter
20 squared is 400

60
Figure 6-11
result square(value)
20
int square(int number) return number
number
61
6.9 Returning Boolean Values

Function may return true or false values.

62
Program 6-15

// This program uses a function that returns true
or false.
include ltiostream.hgt
// Function prototype
bool isEven(int)
void main(void)
int val
cout ltlt "Enter an integer and I will tell you "
cout ltlt "if it is even or odd "
cin gtgt val
if (isEven(val))
cout ltlt val ltlt " is even.\n"
else
cout ltlt val ltlt " is odd.\n"

63
Program continues

//
// Definition of function isEven. This function
accepts an
// integer argument and tests it to be even or
odd. The function
// returns true if the argument is even or false
if the argument is
// odd.
// The return value is bool.
//
bool isEven(int number)
bool status
if (number 2)
status false // The number is odd if there's
a remainder.
else
status true // Otherwise, the number is
even.
return status

64
Program Output

Enter an integer and I will tell you if it is
even or odd 5 Enter
5 is odd.

65
6.10 Local and Global Variables

A local variable is declared inside a function,
and is not accessible outside the function.
A global variable is declared outside all
functions and is accessible in its scope.

66
Program 6-16

// This program shows that variables declared in
a function
// are hidden from other functions.
include ltiostream.hgt
void func(void) // Function prototype
void main(void)
int num 1
cout ltlt "In main, num is " ltlt num ltlt endl
func()
cout ltlt "Back in main, num is still " ltlt num ltlt
endl

67
Program continues

//
// Definition of function func.
// It has a local variable, num, whose initial
value, 20,
// is displayed.
//
void func(void)
int num 20
cout ltlt "In func, num is " ltlt num ltlt endl

68
Program Output

In main, num is 1
In func, num is 20
Back in main, num is still 1

69
Figure 6-8
Function main num 1
This num variable is only visible in function
main.
Function func num 20
This num variable is only visible in function
func.
70
Program 6-17

// This program shows that a global variable is
visible
// to all the functions that appear in a program
after
// the variable's declaration.
include ltiostream.hgt
void func(void) // Function prototype
int num 2 // Global variable
void main(void)
cout ltlt "In main, num is " ltlt num ltlt endl
func()
cout ltlt "Back in main, num is " ltlt num ltlt endl

71
Program continues

//
// Definition of function func.
// func changes the value of the global variable
num
//
void func(void)
cout ltlt "In func, num is " ltlt num ltlt endl
num 50
cout ltlt "But, it is now changed to " ltlt num ltlt
endl

72
Program Output

In main, num is 2
In func, num is 2
But, it is now changed to 50
Back in main, num is 50

73
Program 6-18

// This program shows that a global variable is
visible
// to all the functions that appear in a program
after
// the variable's declaration.
include ltiostream.hgt
void func(void) // Function prototype
void main(void)
cout ltlt "In main, num is not visible!\n"
func()
cout ltlt "Back in main, num still isn't
visible!\n"

74
Program continues

int num 2 // Global variable
//
// Definition of function func
// func changes the value of the global variable
num.
//
void func(void)
cout ltlt "In func, num is " ltlt num ltlt endl
num 50
cout ltlt "But, it is now changed to " ltlt num ltlt
endl

75
Program Output

In main, num is not visible!
In func, num is 2
But, it is now changed to 50
Back in main, num still isn't visible!

76
Global Variables are Initialized to Zero by
Default

Unless you explicitly initialize numeric global
variables, they are automatically initialized to
zero.
Global character variables are initialized to
NULL, or ASCII code 0.

77
Program 6-19

// This program has an uninitialized global
variable.
include ltiostream.hgt
int globalNum // Global variable. Automatically
set to zero.
void main(void)
cout ltlt "globalNum is " ltlt globalNum ltlt endl

78
Program Output

globalNum is 0

79
Local and Global Variables with the Same Name

If a function has a local variable with the same
name as a global variable, only the local
variable can be seen by the function.

80
Program 6-20

// This program shows that when a local variable
has the
// same name as a global variable, the function
only sees
// the local variable.
include ltiostream.hgt
// Function prototypes
void texas()
void arkansas()
int cows 10
void main(void)
cout ltlt "There are " ltlt cows ltlt " cows in
main.\n"
texas()
arkansas()
cout ltlt "Back in main, there are " ltlt cows ltlt "
cows.\n"

81
Program continues

//
// Definition of function texas.
// The local variable cows is set to 100.
//
void texas(void)
int cows 100
cout ltlt "There are " ltlt cows ltlt " cows in
texas.\n"

82
Program continues

//
// Definition of function arkansas.
// The local variable cows is set to 50.
//
void arkansas(void)
int cows 50
cout ltlt "There are " ltlt cows ltlt " cows in
arkansas.\n"

83
Program Output

There are 10 cows in main.
There are 100 cows in texas.
There are 50 cows in arkansas.
Back in main, there are 10 cows.

84
Program 6-21

// This program has local and global variables.
In the function
// ringUpSale, there is a local variable named
tax. There is
// also a global variable with the same name.
include ltiostream.hgt
void ringUpSale(void) // Function prototype
// Global Variables
const float taxRate 0.06
float tax, sale, total
void main(void)
char again

85
Program continues

cout.precision(2)
cout.setf(iosfixed iosshowpoint)
do
ringUpSale()
cout ltlt "Is there another item to be purchased?
"
cin gtgt again
while (again 'y' again 'Y')
tax sale taxRate
total sale tax
cout ltlt "The tax for this sale is " ltlt tax ltlt
endl
cout ltlt "The total is " ltlt total ltlt endl

86
Program continues

//
// Definition of function ringUpSale.
// This function asks for the quantity and unit
price of an item.
// It then calculates and displays the sales tax
and subtotal
// for those items.
//
void ringUpSale(void)
int qty
float unitPrice, tax, thisSale, subTotal
cout ltlt "Quantity "
cin gtgt qty
cout ltlt "Unit price "
cin gtgt unitPrice
thisSale qty unitPrice // Get the total
unit price

87
Program continues

sale thisSale // Update global
variable sale
tax thisSale taxRate // Get sales tax for
these items
subTotal thisSale tax // Get subtotal for
these items
cout ltlt "Price for these items " ltlt thisSale ltlt
endl
cout ltlt "tax for these items " ltlt tax ltlt endl
cout ltlt "subTotal for these items " ltlt subTotal
ltlt endl

88
Program Output with Example Input

Quantity 2 Enter
Unit Price 20.00 Enter
Price for these items 40.00
tax for these items 2.40
subTotal for these items 42.40
Is there another item to be purchased? y Enter
Quantity 3 Enter
Unit Price 12.00 Enter
Price for these items 36.00
tax for these items 2.16
subTotal for these items 38.16
Is there another item to be purchased? n Enter
The tax for this sale is 4.56
The total is 80.56

89
Be Careful With Global Variables

It is tempting to make all your variables global.
But dont do it!
Using global variables can cause problems.
It is harder to debug a program that uses global
variables

90
6.11 Static Local Variables

If a function is called more than once in a
program, the values stored in the functions
local variables do not persist between function
calls.
To get a variable to keep its value even after
the function ends, you must create static
variables

91
Program 6-22

// This program shows that local variables do not
retain
// their values between function calls.
include ltiostream.hgt
// Function prototype
void showLocal(void)
void main(void)
showLocal()
showLocal()

92
Program continues

//
// Definition of function showLocal.
// The initial value of localNum, which is 5, is
displayed.
// The value of localNum is then changed to 99
before the
// function returns.
//
void showLocal(void)
int localNum 5 // Local variable
cout ltlt "localNum is " ltlt localNum ltlt endl
localNum 99

93
Program Output

localNum is 5
localNum is 5

94
Program 6-23

//This program uses a static local variable.
include ltiostream.hgt
void showStatic(void) // Function prototype
void main(void)
for (int count 0 count lt 5 count)
showStatic()
//
// Definition of function showStatic.
// statNum is a static local variable. Its value
is displayed
// and then incremented just before the function
returns.
//
void showStatic(void)
static int statNum
cout ltlt "statNum is " ltlt statNum ltlt endl

95
Program Output

statNum is 0
statNum is 1
statNum is 2
statNum is 3
statNum is 4

96
Program 6-24

// This program shows that a static local
variable is only
// initialized once.
include ltiostream.hgt
void showStatic(void) // Function prototype
void main(void)
for (int count 0 count lt 5 count)
showStatic()

97
Program continues

//
// Definition of function showStatic.
// statNum is a static local variable. Its value
is displayed
// and then incremented just before the function
returns.
//
void showStatic()
static int statNum 5
cout ltlt "statNum is " ltlt statNum ltlt endl
statNum

98
Program Output

statNum is 5
statNum is 6
statNum is 7
statNum is 8
statNum is 9

99
6.12 Default Arguments

Default arguments are passed to parameters
automatically if no argument is provided in the
function call.
A functions default arguments should be assigned
in the earliest occurrence of the function name.
This will usually mean the function prototype.

100
Program 6-25

// This program demonstrates default function
arguments.
include ltiostream.hgt
// Function prototype with default arguments
void displayStars(int 10, int 1)
void main(void)
displayStars()
cout ltlt endl
displayStars(5)
cout ltlt endl
displayStars(7, 3)

101
Program continues

//
// Definition of function displayStars.
// The default argument for cols is 10 and for
rows is 1.
// This function displays a rectangle made of
asterisks.
//
void displayStars(int cols, int rows)
// Nested loop. The outer loop controls the rows
// and the inner loop controls the columns.
for (int down 0 down lt rows down)
for (int across 0 across lt cols across)
cout ltlt ""
cout ltlt endl

102
Program Output

103
Default Argument Summary

The value of a default argument must be a
constant (either a literal value of a named
constant).
When an argument is left out of a function call
(because it has a default value), all the
arguments that come after it must be left out
too.
When a function has a mixture of parameters both
with and without default arguments, the
parameters with default arguments must be
declared last.

104
6.13 Using Reference Variables as Parameters

When used as parameters, reference variables
allow a function to access the parameters
original argument, changes to the parameter are
also made to the argument.

105
Example

void doubleNum(int refVar)
refVar 2
// The variable refVar is called
// a reference to an int

106
Program 6-26

// This program uses a reference variable as a
function
// parameter.
include ltiostream.hgt
// Function prototype. The parameter is a
reference variable.
void doubleNum(int )
void main(void)
int value 4
cout ltlt "In main, value is " ltlt value ltlt endl
cout ltlt "Now calling doubleNum..." ltlt endl
doubleNum(value)
cout ltlt "Now back in main. value is " ltlt value
ltlt endl

107
Program continues

//
// Definition of doubleNum.
// The parameter refVar is a reference variable.
The value
// in refVar is doubled.
//
void doubleNum (int refVar)
refVar 2

108
Program Output

In main, value is 4
Now calling doubleNum...
Now back in main. value is 8

109
Program 6-27

// This program uses reference variables as
function
// parameters.
include ltiostream.hgt
// Function prototypes. Both functions use
reference variables
// as parameters
void doubleNum(int )
void getNum(int )
void main(void)
int value
getNum(value)
doubleNum(value)
cout ltlt "That value doubled is " ltlt value ltlt
endl

110
Program continues

//
// Definition of getNum.
// The parameter userNum is a reference variable.
The user is
// asked to enter a number, which is stored in
userNum.
//
void getNum(int userNum)
cout ltlt "Enter a number "
cin gtgt userNum

111
Program continues

//
// Definition of doubleNum.
// The parameter refVar is a reference variable.
The value
// in refVar is doubled.
//
void doubleNum (int refVar)
refVar 2

112
Program Output with Example Input

Enter a number 12 Enter
That value doubled is 24

113
Reference Argument Warning

Dont get carried away with using reference
variables as function parameters. Any time you
allow a function to alter a variable thats
outside the function, you are creating potential
debugging problems. Reference variables should
only be used as parameters when the situation
demands them.

114
6.14 Overloaded Functions

Two or more functions may have the same name as
long as their parameter lists are different.

115
Program 6-28

include ltiostream.hgt
// Function prototypes
int square(int)
float square(float)
void main(void)
int userInt
float userFloat
cout.precision(2)
cout ltlt "Enter an integer and a floating-point
value "
cin gtgt userInt gtgt userFloat
cout ltlt "Here are their squares "
cout ltlt square(userInt) ltlt " and " ltlt
square(userFloat)

116
Program continues

// Definition of overloaded function square.
// This function uses an int parameter, number.
It returns the
// square of number as an int.
int square(int number)
return number number
// Definition of overloaded function square.
// This function uses a float parameter, number.
It returns the
// square of number as a float.
float square(float number)
return number number

117
Program Output with Example Input

Enter an integer and floating-point value 12 4.2
Enter
Here are their squares 144 and 17.64

118
Program 6-29

// This program demonstrates overloaded functions
to calculate
// the gross weekly pay of hourly-paid or
salaried employees.
include ltiostream.hgt
// Function prototypes
void getChoice(char )
float calcWeeklyPay(int, float)
float calcWeeklyPay(float)
void main(void)
char selection
int worked
float rate, yearly
cout.precision(2)
cout.setf(iosfixed iosshowpoint)
cout ltlt Do you want to calculate the weekly pay
of\n"
cout ltlt (H) an hourly-paid employee, or \n

119
Program continues

getChoice(selection)
switch (selection)
case H
case h cout ltlt How many hours were
worked?
cin gtgt worked
cout ltlt What is the hour pay
rate?
cin gtgt rate
cout ltlt The gross weekly pay is
cout ltlt calcWeeklyPay(worked,
rate)
break
case S
case s cout ltlt What is the annual
salary?
cin gtgt yearly
cout ltlt The gross weekly pay is
cout ltlt calcWeeklyPay(yearly)
break

120
Program continues

//
// Definition of function getChoice.
// The parameter letter is a reference to a char.
// This function asks the user for an H or an S
and returns
// the validated input.
//
void getChoice(char letter)
do
cout ltlt Enter your choice (H or S)
cin gtgt letter
while (letter ! H letter ! h
letter ! S letter ! s)

121
Program continues

//
// Definition of overloaded function
calcWeeklyPay.
// This function calculates the gross weekly pay
of
// an hourly-paid employee. The parameter hours
hold the
// hourly pay rate. The function returns the
weekly salary.
//
void calcWeekly(int hours, float payRate)
return hours payRate

122
Program continues

//
// Definition of overloaded function
calcWeeklyPay.
// This function calculates the gross weekly pay
of
// a salaried employee. The parameter holds the
employees
// annual salary. The function returns the weekly
salary.
//
void calcWeekly(float annSalary)
return annSalary / 52.0

123

Program Output with Example Input
Do you want to calculate the weekly pay of
(H) an houly-paid employee, or
(S) a salaried employee? HEnter
How many hours were worked? 40Enter
What is the hour pay rate? 18.50Enter
The gross weekly pay is 740.00
Program Output with Other Example Input
Do you want to calculate the weekly pay of
(H) an houly-paid employee, or
(S) a salaried employee? SEnter
What is the annual salary? 48000.00Enter
The gross weekly pay is 923.08

124
6.15 The exit() Function

The exit() function causes a program to
terminate, regardless of which function or
control mechanism is executing.

125
Program 6-30

// This program shows how the exit function
causes a program
// to stop executing.
include ltiostream.hgt
include ltstdlib.hgt // For exit
void function(void) // Function prototype
void main(void)
function()

126
Program continues

//
// This function simply demonstrates that exit
can be used
// to terminate a program from a function other
than main.
//
void function(void)
cout ltlt "This program terminates with the exit
function.\n"
cout ltlt "Bye!\n"
exit(0)
cout ltlt "This message will never be
displayed\n"
cout ltlt "because the program has already
terminated.\n"

127
Program Output

This program terminates with the exit function.
Bye!

128
Program 6-31

// This program demonstrates the exit function.
include ltiostream.hgt
include ltstdlib.hgt // For exit
void main(void)
char response
cout ltlt "This program terminates with the exit
function.\n"
cout ltlt "Enter S to terminate with the
EXIT_SUCCESS code\n"
cout ltlt "or f to terminate with the EXIT_FAILURE
code "
cin gtgt response

129
Program continues

if (response 'S')
cout ltlt "Exiting with EXIT_SUCCESS.\n"
exit(EXIT_SUCCESS)
else
cout ltlt "Exiting with EXIT_FAILURE.\n"
exit(EXIT_FAILURE)

130
Program Output with Example Input

This program terminates with the exit function.
Enter S to terminate with the EXIT_SUCCESS code
or f to terminate with the EXIT_FAILURE code s
Enter
Exiting with EXIT_SUCCESS.
Program Output With Other Example Input
This program terminates with the exit function.
Enter S to terminate with the EXIT_SUCCESS code
or f to terminate with the EXIT_FAILURE code f
Enter
Exiting with EXIT_FAILURE.

131
6.16 Stubs and Drivers

Stubs and drivers are very helpful tools for
testing and debugging programs that use
functions.
A stub is a dummy function that is called instead
of the actual function it represents.
A driver is a program that tests a function by
simply calling it.

132