C++ for

Engineers and Scientists

Third Edition

Chapter 6
Modularity Using Functions
 Objectives
• In this chapter, you will learn about:
– Function and parameter declarations
– Returning a single value
– Returning multiple values
– Rectangular to polar coordinate conversion
– Variable scope
– Variable storage categories
– Common programming errors

C++ for Engineers and Scientists, Third Edition 2

 Function and Parameter Declarations
• Interaction with a function includes:
– Passing data to a function correctly when its called
– Returning values from a function when it ceases
operation
• A function is called by giving the function’s name
and passing arguments in the parentheses
following the function name

Figure 6.1 Calling and passing data to a function

C++ for Engineers and Scientists, Third Edition 3

 Function and Parameter Declarations
(continued)

C++ for Engineers and Scientists, Third Edition 4

 Function and Parameter Declarations
(continued)
• Before a function is called, it must be declared to
function that will do calling
• Declaration statement for a function is referred to as
function prototype
• Function prototype tells calling function:
– Type of value that will be formally returned, if any
– Data type and order of the values the calling function
should transmit to the called function
• Function prototypes can be placed with the variable
declaration statements above the calling function
name or in a separate header file
C++ for Engineers and Scientists, Third Edition 5
 Calling a Function
• Requirements when calling a function include:
– Using the name of the function
– Enclosing any data passed to the function in the
parentheses following the function name, using the
same order and type declared in the function
prototype

C++ for Engineers and Scientists, Third Edition 6

 Calling a Function (continued)
• The items enclosed in the parentheses are called
arguments of the called function

Figure 6.2 Calling and passing two values to findMax()

C++ for Engineers and Scientists, Third Edition 7

 Calling a Function (continued)

Figure 6.3 The findMax() function receives actual values

C++ for Engineers and Scientists, Third Edition 8

 Calling a Function (continued)
• Figure 6.3:
– The findMax() function does not receive the
variables named firstnum and secnum and has no
knowledge of the variable names
– The function receives the values in these variables and
must then determine where to store those values
before it does anything else

C++ for Engineers and Scientists, Third Edition 9

 Defining a Function
• Every C++ function consists of two parts:
• Function header
• Function body
• Function header’s purpose:
– Identify data type of value function returns, provide
function with name, and specify number, order, and
type of arguments function expects
• Function body’s purpose:
– To operate on passed data and return, at most, one
value directly back to the calling function

C++ for Engineers and Scientists, Third Edition 10

 Defining a Function (continued)
Figure 6.4 The general
format of a function

Figure 6.5 Storing

values in parameters

C++ for Engineers and Scientists, Third Edition 11

 Placement of Statements
• General rule for placing statements in a C++
program:
– All preprocessor directives, named constants,
variables, and functions must be declared or defined
before they can be used
– Although this rule permits placing both preprocessor
directives and declaration statements throughout the
program, doing so results in poor program structure

C++ for Engineers and Scientists, Third Edition 12

Functions with Empty Parameter Lists
• Although useful functions having an empty
parameter list are extremely limited, they can occur
• Function prototype for such a function requires
writing the keyword void or nothing at all between
the parenthesis following the function’s name

C++ for Engineers and Scientists, Third Edition 13

 Default Arguments
• C++ provides default arguments in a function call
for added flexibility
• Primary use of default arguments is to extend
parameter list of existing functions without requiring
any change in calling parameter lists already used
in a program
• Default arguments are listed in the function
prototype and transmitted automatically to the
called function when the corresponding arguments
are omitted from the function call

C++ for Engineers and Scientists, Third Edition 14

 Default Arguments (continued)
• Example: Function prototype with default
arguments
void example(int, int = 5, double = 6.78)
• Sample valid calls to the example function
example(7,2,9.3) // no defaults used
example(7,2) // same as example(7, 2, 6.78)
example(7) // same as example(7, 5, 6.78)

C++ for Engineers and Scientists, Third Edition 15

 Reusing Function Names
(Overloading)
• C++ provides the capability of using the same
function name for more than one function
– Referred to as function overloading
• Only requirement for creating more than one
function with same name:
– Compiler must be able determine which function to
use based on the parameters’ data types (not the
data type of the return value, if any)

C++ for Engineers and Scientists, Third Edition 16

 Reusing Function Names
(Overloading) (continued)
• Which of the functions is called depends on the
argument type supplied at the time of the call

C++ for Engineers and Scientists, Third Edition 17

 Function Templates
• Function template: Single complete function that
serves as a model for a family of functions
– Function from the family that is actually created
depends on the specific function call
• Generalize the writing of functions that perform
essentially the same operation, but on different
parameter data types
• Make it possible to write a general function that
handles all cases but where the compiler can set
parameters, variables, and even return type based
on the actual function call
C++ for Engineers and Scientists, Third Edition 18
 Returning a Single Value
• Function receiving an argument passed by value
cannot inadvertently alter value stored in the
variable used for the argument
• Function receiving passed by value arguments can
process the values sent to it in any fashion and
return one, and only one, “legitimate” value directly
to the calling function

Figure 6.6 A
function directly
returns at most one
value

C++ for Engineers and Scientists, Third Edition 19

 Returning a Single Value (continued)
• findmax function

C++ for Engineers and Scientists, Third Edition 20

 Inline Functions
• Calling a function places a certain amount of
overhead on a computer
– Placing argument values in a reserved memory
region (called the stack) that the function has access
to
– Passing control to the function
– Providing a reserved memory location for any
returned value (again, using the stack for this
purpose
– Returning to the correct point in the calling program

C++ for Engineers and Scientists, Third Edition 21

 Inline Functions (continued)
• Paying overhead associated with calling a function
is justified when a function is called many times
• Can reduce a program’s size substantially
• For small functions that are not called many times,
overhead of passing and returning values might not
be warranted
• Inline functions:
– Group repeating lines of code together under a
common function name
– Have the compiler place this code in the
program wherever the function is called
C++ for Engineers and Scientists, Third Edition 22
 Inline Functions (continued)

C++ for Engineers and Scientists, Third Edition 23

 Inline Functions (continued)
• Advantage: Increase in execution speed
– Because the inline function is expanded and
included in every expression or statement calling it,
no execution time is lost because of the call and
return overhead a non-inline function requires
• Each time an inline function is referenced the
complete code is reproduced and stored as an
integral part of the program
• A non-inline function is stored in memory only once
• Inline functions should be used only for small
functions that aren’t called extensively in a program
C++ for Engineers and Scientists, Third Edition 24
 Returning Multiple Values
• In typical function invocation, called function
receives values from its calling function stores and
manipulates the passed values, and directly returns
at most one value
• Pass by value: When data is passed in this
manner
• Pass by reference: Giving a called function direct
access to its calling function’s variables is referred
to as
• The called function can reference, or access, the
variable whose address has been passed as a pass
by reference argument
C++ for Engineers and Scientists, Third Edition 25
 Passing and Using Reference
Parameters
• From the sending side, calling a function and
passing an address as an argument that’s accepted
as a reference parameter is the same as calling a
function and passing a value
• Whether a value or an address is actually passed
depends on the parameter types declared

C++ for Engineers and Scientists, Third Edition 26

 Passing and Using Reference
Parameters (continued)

Figure 6.7 The equivalence of arguments and parameters in Program 6.8

C++ for Engineers and Scientists, Third Edition 27

 Passing and Using Reference
Parameters (continued)

C++ for Engineers and Scientists, Third Edition 28

 Passing and Using Reference
Parameters (continued)

Figure 6.8 The relationship between argument and parameter names

C++ for Engineers and Scientists, Third Edition 29

 Passing and Using Reference
Parameters (continued)

Figure 6.9a Save the first value

Figure 6.9b Replace the first value with the second value

Figure 6.9c Change the second value

C++ for Engineers and Scientists, Third Edition 30
 A Case Study: Rectangular to Polar
Coordinate Conversion

Figure 6.10 The problem-solver algorithm

C++ for Engineers and Scientists, Third Edition 31

 A Case Study: Rectangular to Polar
Coordinate Conversion (continued)

Figure 6.11 The correspondence between polar (distance and angle)

and Cartesian (x and y) coordinates

C++ for Engineers and Scientists, Third Edition 32

 A Case Study: Rectangular to Polar
Coordinate Conversion (continued)

Figure 6.12 A top level structure diagram

C++ for Engineers and Scientists, Third Edition 33

 A Case Study: Rectangular to Polar
Coordinate Conversion (continued)

Figure 6.13 Parameter values when polar() is called

C++ for Engineers and Scientists, Third Edition 34

 A Case Study: Rectangular to Polar
Coordinate Conversion (continued)

C++ for Engineers and Scientists, Third Edition 35

 Variable Scope
• A function can be thought of as a closed box, with
slots at the top to receive values and a single slot at
the bottom to return a value

Figure 6.14 A function

can be considered a
closed box

C++ for Engineers and Scientists, Third Edition 36

 Variable Scope (continued)
• Local variables: Variables created in a function
that are conventionally available only to the function
• Scope: Section of the program where the identifier
is valid or “known”
• A variable with local scope is simply one with
storage locations set aside for it by a declaration
statement inside the function that declared them
• A variable with global scope has storage created
for it by a declaration statement located outside any
function

C++ for Engineers and Scientists, Third Edition 37

 Variable Scope (continued)

Figure 6.15 The three storage areas reserved by Program 6.15

C++ for Engineers and Scientists, Third Edition 38

 Variable Scope (continued)

Figure 6.16 Relating the scope and type of a variable

C++ for Engineers and Scientists, Third Edition 39

 Scope Resolution Operator
• When a local variable has the same name as a
global variable, all references to the variable name
made within the local variable’s scope refer to the
local variable

C++ for Engineers and Scientists, Third Edition 40

 Scope Resolution Operator
(continued)
• To reference a global variable when a local variable of the
same name is in scope, use C++’s scope resolution operator,
which is ::

C++ for Engineers and Scientists, Third Edition 41

 Misuse of Globals
• Global variables allow programmers to “jump
around” the normal safeguards provided by
functions
• Instead of passing variables to a function, it is
possible to make all variables global: do not do this
– Indiscriminate use of global variables destroys the
safeguards C++ provides to make functions
independent and insulated from each other
– Using only global variables can be especially
disastrous in large programs with many user-created
functions

C++ for Engineers and Scientists, Third Edition 42

 Variable Storage Categories
• A variable’s scope can be thought of as the space
in the program where the variable is valid
• In addition to space dimension represented by
scope, variables have a time dimension that refers
to the length of time storage locations are reserved
for a variable
• This time, dimension is referred to as the variable’s
lifetime
• When and how long a variable’s storage locations
are kept before they are released can be
determined by the variable’s storage category
C++ for Engineers and Scientists, Third Edition 43
 Variable Storage Categories
(continued)
• The four available storage categories are:
– auto
– static
– extern
– register

C++ for Engineers and Scientists, Third Edition 44

 Local Variable Storage Categories
• Local variables can be members only of the auto,
static, or register storage categories
– auto is short for automatic
• Storage for automatic local variables is reserved or
created automatically each time a function
– As long as the function hasn’t returned control to its
calling function, all automatic variables local to the
function are “alive”
• A local static variable isn’t created and destroyed
each time the function declaring it is called
– Local static variables remain in existence for the
program’s lifetime
C++ for Engineers and Scientists, Third Edition 45
 Local Variable Storage Categories
(continued)

C++ for Engineers and Scientists, Third Edition 46

 Local Variable Storage Categories
(continued)

C++ for Engineers and Scientists, Third Edition 47

 Local Variable Storage Categories
(continued)
• Most computers have a few high-speed storage
areas, called registers, located in the CPU that can
also be used for variable storage
– Because registers are located in the CPU, they can
be accessed faster than normal memory storage
areas located in the computer’s memory unit

C++ for Engineers and Scientists, Third Edition 48

 Global Variable Storage Categories
• Global variables are created by definition
statements external to a function
• By their nature, global variables do not come and
go with the calling of a function
• After a global variable is created, it exists until the
program in which it’s declared has finished
executing
• Global variables can be declared with the static
or extern storage category, but not both

C++ for Engineers and Scientists, Third Edition 49

 Global Variable Storage Categories
(continued)

Figure 6.17 A program can extend beyond one file

C++ for Engineers and Scientists, Third Edition 50

 Global Variable Storage Categories
(continued)

Figure 6.18 Extending the scope of global variables

C++ for Engineers and Scientists, Third Edition 51

 Common Programming Errors
• Passing incorrect data types
• Errors that occur when the same variable is
declared locally in both the calling and the called
functions
• Omitting the called function’s prototype before or
within the calling function
• Terminating a function header with a semicolon
• Forgetting to include the data type of a function’s
parameters in the function header

C++ for Engineers and Scientists, Third Edition 52

 Chapter Summary
• A function is called by giving its name and passing
any data to it in the parentheses following the name
• A function’s return type is the data type of the value
the function returns
• Arguments passed to a function when it is called
must conform to the parameters specified by the
function header in terms of order, number of
arguments, and specified data type

C++ for Engineers and Scientists, Third Edition 53

 Chapter Summary (continued)
• Functions can be declared to all calling functions by
means of a function prototype
• Every variable has a storage category, which
determines how long the value in the variable is
retained

C++ for Engineers and Scientists, Third Edition 54