C++ Programming:

Program Design Including

Data Structures, Third Edition

Chapter 7: User-Defined Functions II

Objectives

In this chapter you will:

• Learn how to construct and use void functions
in a program
• Discover the difference between value and
reference parameters
• Explore reference parameters and value-
returning functions
• Learn about the scope of an identifier
Objectives

• Examine the difference between local and

global identifiers

• Discover static variables

• Learn function overloading

• Explore functions with default parameters

void Functions

• void functions and value-returning functions

have similar structures

− Both have a heading part and a statement part

• User-defined void functions can be placed

either before or after the function main
void Functions (Continued)

• The program execution always begins with

the first statement in the function main

• If user-defined void functions are placed after

the function main

− The function prototype must be placed before

the function main
void Functions (continued)

• A void function does not have a return type

• The return statement without any value is

typically used to exit the function early

• Formal parameters are optional

• A call to a void function is a stand-alone

statement
void Functions Without Parameters

• Function definition syntax:

• void is a reserved word

• Function call syntax:
void Functions With Parameters

• Function definition syntax:

void Functions With Parameters
(continued)
• A formal parameter receives a copy of the
content of corresponding actual parameter

• Reference Parameter - a formal parameter

that receives the location (memory address)
of the corresponding actual parameter
Value Parameters

• If a formal parameter is a value parameter

− The value of the corresponding actual
parameter is copied into it
• The value parameter has its own copy of the
data
• During program execution
− The value parameter manipulates the data
stored in its own memory space
Reference Variables as Parameters

• If a formal parameter is a reference

parameter

− It receives the address of the corresponding

actual parameter

• A reference parameter stores the address of

the corresponding actual parameter
Reference Variables as Parameters
(continued)
• During program execution to manipulate the
data

− The address stored in the reference parameter

directs it to the memory space of the
corresponding actual parameter
Reference Variables as Parameters
(continued)
 A reference parameter receives the address
of the actual parameter

 Reference parameters can:

 Pass one or more values from a function

 Change the value of the actual parameter

Reference Variables as Parameters
(continued)
 Reference parameters are useful in three
situations:

 Returning more than one value

 Changing the actual parameter

 When passing the address would save

memory space and time
Parameters & Memory Allocation
• When a function is called
− Memory for its formal parameters and
variables declared in the body of the function
(called local variables) is allocated in the
function data area
• In the case of a value parameter
− The value of the actual parameter is copied
into the memory cell of its corresponding
formal parameter
Parameters & Memory Allocation
(continued)
• In the case of a reference parameter

− The address of the actual parameter passes to

the formal parameter

• Content of the formal parameter is an

address
Parameters & Memory Allocation
(continued)
• During execution, changes made by the
formal parameter permanently change the
value of the actual parameter

• Stream variables (for example, ifstream and

ofstream) should be passed by reference to a
function
Scope of an Identifier

• The scope of an identifier refers to where in

the program an identifier is accessible
• Local identifier - identifiers declared within a
function (or block)
• Global identifier – identifiers declared outside
of every function definition
• C++ does not allow nested functions
− The definition of one function cannot be
included in the body of another function
Global Variables

• Some compilers initialize global variables to

default values
• The operator :: is called the scope resolution
operator
• By using the scope resolution operator
− A global variable declared before the definition
of a function (block) can be accessed by the
function (or block) even if the function (or block)
has an identifier with the same name as the
variable
Global Variables (continued)

• C++ provides a way to access a global

variable declared after the definition of a
function

• In this case, the function must not contain any

identifier with the same name as the global
variable
Side Effects of Global Variables

• Using global variables has side effects

• Any function that uses global variables

− Is not independent

− Usually cannot be used in more than one

program
Side Effects of Global Variables
(continued)
• If more than one function uses the same
global variable and something goes wrong

− It is difficult to find what went wrong and where

• Problems caused by global variables in one

area of a program might be misunderstood as
problems caused in another area
Static and Automatic Variables
• Automatic variable - memory is allocated at
block entry and deallocated at block exit
• Static variable - memory remains allocated as
long as the program executes
• Variables declared outside of any block are
static variables
• By default, variables declared within a block
are automatic variables
• Declare a static variable within a block by
using the reserved word static
Static and Automatic Variables
(continued)
• The syntax for declaring a static variable is:
static dataType identifier;
• The statement
static int x;
declares x to be a static variable of the type int
• Static variables declared within a block are
local to the block
• Their scope is the same as any other local
identifier of that block
Function Overloading

• In a C++ program, several functions can have

the same name
• This is called function overloading or
overloading a function name
Function Overloading (continued)

• Two functions are said to have different

formal parameter lists if both functions
have:
− A different number of formal parameters, or
− If the number of formal parameters is the
same, then the data type of the formal
parameters, in the order you list them, must
differ in at least one position
The functions functionSix and functionSeven both have
three formal parameters and the data type of the
corresponding parameters is the same; therefore, these
functions have the same formal parameter list
 Function Overloading (continued)

• Function overloading: creating several functions

with the same name
• The signature of a function consists of the function
name and its formal parameter list
• Two functions have different signatures if they have
either different names or different formal parameter
lists
• Note that the signature of a function does not
include the return type of the function
These function headings correctly overload the function
functionXYZ:

• Both of these function headings have the same name and

same formal parameter list
• Therefore, these function headings to overload the function
functionABC are incorrect
• In this case, the compiler will generate a syntax error
• Note that the return types of these function headings are
different
Functions with Default Parameters

• When a function is called

− The number of actual and formal parameters
must be the same

• C++ relaxes this condition for functions with

default parameters
• You specify the value of a default parameter
when the function name appears for the first
time, such as in the prototype
Functions with Default Parameters
(continued)
• If you do not specify the value of a default
parameter
− The default value is used
• All of the default parameters must be the
rightmost parameters of the function
• In a function call where the function has more
than one default parameter and a value to a
default parameter is not specified
− You must omit all of the arguments to its right
Functions with Default Parameters
(continued)
• Default values can be constants, global
variables, or function calls

• The caller has the option of specifying a value

other than the default for any default
parameter

• You cannot assign a constant value as a

default value to a reference parameter
Programming Example

• In this example
− Using functions, we rewrite the program that
determines the number of odds and evens
from a given list of integers
− This program was first written in Chapter 5
• The main algorithm remains the same:
1. Initialize variables, zeros, odds, and evens to
0
2. Read a number
Programming Example (continued)

3. If the number is even, increment the even

count

− If the number is also zero, increment the zero

count; else increment the odd count

4. Repeat Steps 2 and 3 for each number in the

list
Programming Example (continued)

• The program functions include:

− Initialize: initialize the variables, such as zeros,
odds, and evens
− getNumber: get the number
− classifyNumber: determine whether the number
is odd or even (and whether it is also zero); this
function also increments the appropriate count
− printResults: print the results
Main Algorithm

1. Call function initialize to initialize variables

2. Prompt the user to enter 20 numbers
3. For each number in the list
− Call function getNumber to read a number
− Output the number
− Call function classifyNumber to classify the
number and increment the appropriate count
4. Call function printResults to print the final
results
Summary
• Void function: a function that does not have a
data type
• A return statement without any value can be
used in a void function to exit function early
• The heading of a void function starts with the
word void
• To call a void function, you use the function
name together with the actual parameters in a
stand-alone statement
Summary (continued)

• Two types of formal parameters: value

parameters and reference parameters

• A value parameter receives a copy of its

corresponding actual parameter

• A reference parameter receives the address

(memory location) of its corresponding actual
parameter
Summary (continued)
• If a formal parameter needs to change the value
of an actual parameter, in the function heading
you must declare this formal parameter as a
reference parameter
• Variables declared within a function (or block)
are called local variables
• Variables declared outside of every function
definition (and block) are called global variables
Summary (continued)

• An automatic variable is a variable for which

memory is allocated on function (or block)
entry and deallocated on function (or block)
exit
• A static variable is a variable for which
memory remains allocated throughout the
execution of the program
• C++ allows functions to have default
parameters