1
Scope,Lifetime,and More on
Functions
2
Chapter 8 Topics
Local Scope vs,Global Scope of an Identifier
Detailed Scope Rules to Determine which
Variables are Accessible in a Block
Determining the Lifetime of a Variable
Initializations in Declarations
Interface Design
Writing a Value-Returning Function for a Task
Some Value-Returning Functions with
Prototypes in Header Files cctype and cmath
Creating and Using a Module Structure Chart
Stub Testing a Program
3
Scope of Identifier
the scope of an identifier
(or named constant) means
the region of program code where
it is legal to use that identifier for
any purpose
4
Local Scope vs,Global
Scope
the scope of an
identifier that is
declared inside a
block (this includes
function parameters)
extends from the
point of declaration
to the end of the
block
the scope of an
identifier that is
declared outside of
all namespaces,
functions and classes
extends from point of
declaration to the end
of the entire file
containing program
code
5
const float TAX_RATE = 0.05 ; // global constant
float tipRate ; // global variable
void handle ( int,float ) ; // function prototype
using namespace std ;
int main ( )
{
int age ; // age and bill local to this block
float bill ;
,// a,b,and tax cannot be used here
,// TAX_RATE and tipRate can be used
handle (age,bill) ;
return 0 ;
}
void handle (int a,float b)
{
float tax ; // a,b,and tax local to this block
,// age and bill cannot be used here
,// TAX_RATE and tipRate can be used
}
6
Name Precedence
(or Name Hiding)
when a function declares a local identifier
with the same name as a global identifier,
the local identifier takes precedence
within that function
7
Detailed Scope Rules
1 Function name has global scope,
2 Function parameter scope is identical to scope of a
local variable declared in the outermost block of the
function body.
3 Global variable (or constant) scope extends from
declaration to the end of the file,except as noted in
rule 5.
4 Local variable (or constant) scope extends from
declaration to the end of the block where declared,
This scope includes any nested blocks,except as
noted in rule 5.
5 An identifier?s scope does not include any nested
block that contains a locally declared identifier with
the same name (local identifiers have name
precedence).
8
Figure Scope Diagram for
Scope Rules Program
int a1;
char a2;
int main ( )
{
}
void block1 (
{
}
}
void block2 ( )
{
int a1,
char& b2 )
int c1;
int d2;
int a1;
int b2;
while (…)
{ //Block3
}
int c1;
int b2;
9
Name Precedence Implemented
by Compiler Determines Scope
When an expression refers to an identifier,the
compiler first checks the local declarations.
If the identifier isn?t local,compiler works outward
through each level of nesting until it finds an
identifier with same name,There it stops.
Any identifier with the same name declared at a
level further out is never reached.
If compiler reaches global declarations and still
can?t find the identifier,an error message results.
10
Namespace Scope
the scope of an identifier declared in a
namespace definition extends from the
point of declaration to the end of the
namespace body,and its scope includes
the scope of a using directive specifying
that namespace
11
3 Ways to Use Namespace Identifiers
use a qualified name consisting of the
namespace,the scope resolution operator,,
and the desired the identifier
alpha = std,,abs( beta ) ;
write a using declaration
using std::abs ;
alpha = abs( beta );
write a using directive locally or globally
using namespace std ;
alpha = abs( beta );
12
These allocate memory
int someInt ; // for the global variable
int Square (int n) // for instructions in body
{
int result ; // for the local variable
result = n * n ;
return result ;
}
Variable Declarations and Definitions
13
These do NOT allocate memory
int Square (int n) ; // function prototype
extern int someInt ; // someInt is global
// variable defined in
// another file
14
Lifetime of a Variable
the lifetime of a variable is the time
during program execution when an
identifier actually has memory
allocated to it
15
Lifetime of Local Automatic
Variables
their storage is created (allocated)
when control enters the function
local variables are,alive” while
function is executing
their storage is destroyed
(deallocated) when function exits
16
Lifetime of Global Variables
their lifetime is the lifetime of the
entire program
their memory is allocated when
program begins execution
their memory is deallocated when
the entire program terminates
17
Automatic vs,Static Variable
storage for
automatic variable
is allocated at block
entry and
deallocated at block
exit
storage for static
variable remains
allocated throughout
execution of the
entire program
18
By default
local variables are automatic
to obtain a static local variable,you
must use the reserved word static in
its declaration.
19
Static and Automatic
Local Variables
int popularSquare( int n)
{
static int timesCalled = 0 ; // initialized only once
int result = n * n ; // initialized each time
timesCalled = timesCalled + 1 ;
cout <<,Call #,<< timesCalled << endl ;
return result ;
}
20
Initializations in Declarations
First declare a variable,and then,in a
separate statement,assign an initial
value to the variable,
Example,int sum;
sum = 0;
Combine these two statements into one.
Example,int sum = 0;
21
Initializations in
Declarations(cont.)
An automatic variable is initialized to the
specified value each time control enters
the block.
Initialization of a static variable occurs
only once,
Keep an initialization close to the
executable statements that depend on
that variable.
22
Data Flow Determines
Passing-Mechanism
Incoming /* in */ Pass-by-value
Outgoing /* out */ Pass-by-reference
Incoming/outgoing Pass-by-reference
/* inout */
Parameter Data Flow Passing-Mechanism
Interface Design
23
Side Effects
Any effect of one function on another that is not a part
of the explicitly defined interface between them,
COMMUNICATION
INTERFACE
main function
and
other functions
Parameter list
A typical
function
Figure Side Effects
effectsside
24
Global Constant
The values of global constants cannot be
changed while the program is running,no side
effects can occur.
Two advantages to referencing constants
globally:ease of change,and consistency;By
declaring a constant in only one place,we also
ensure that all parts of the program use
exactly the same value.
Not to say that you should declare all
constants globally.
25
Value-Returning Functions
From the caller’s perspective,the main
difference between void functions and value-
returning functions is that a call to a void
function is a complete statement;a call to a
value-returning function is part of an
expression.
From a design perspective,value-returning
functions are used when there is only one
result returned by a function and that result is
to be used directly in an expression.
Function value type,The date type of the
result value returned by a function,
26
Program with Several Functions
Square function
Cube function
function prototypes
main function
27
Value-returning Functions
#include <iostream>
int Square ( int ) ; // prototypes
int Cube ( int ) ;
using namespace std;
int main ( )
{
cout <<,The square of 27 is,
<< Square (27) << endl; // function call
cout <<,The cube of 27 is,
<< Cube (27) << endl; // function call
return 0;
}
28
Rest of Program
int Square ( int n ) // header and body
{
return n * n;
}
int Cube ( int n ) // header and body
{
return n * n * n;
}
29
Prototype for float Function
called AmountDue( ) with 2 parameters
The first is type char,the other is type int.
float AmountDue ( char,int ) ;
This function will find and return the amount due for
local phone calls,A char value?U? or?L? indicates
Unlimited or Limited service,and the int holds the
number of calls made.
Assume Unlimited service is $40.50 per month.
Limited service is $19.38 for up to 30 calls,and $.09 per
additional call.
30
float AmountDue (char kind,int calls) // 2 parameters
{
float result ; // 1 local variable
const float UNLIM_RATE = 40.50,
LIM_RATE = 19.38,
EXTRA =,09 ;
if (kind ==?U?)
result = UNLIM_RATE ;
else if ( ( kind ==?L? ) && ( calls <= 30) )
result = LIM_RATE ;
else
result = LIM_RATE + (calls - 30) * EXTRA ;
return result ;
}
31
#include <iostream>
#include <fstream>
float AmountDue ( char,int ) ; // prototype
using namespace std ;
void main ( )
{ ifstream myInfile ;
ofstream myOutfile ;
int areaCode,Exchange,phoneNumber,calls ;
int count = 0 ;
float bill ;
char service ;
.,,,,,// open files
while ( count < 100 )
{
myInfile >> service >> phoneNumber >> calls ;
bill = AmountDue (service,calls) ; // function call
myOutfile << phoneNumber << bill << endl ;
count++ ;
}
.,,,,,// close files
}
32
To handle the call
AmountDue(service,calls)
MAIN PROGRAM MEMORY
TEMPORARY MEMORY for function to use
Locations:
Locations:
calls bill service
calls result kind
4000 4002 4006
7000 7002 7006
200? ‘ U?
33
Handling Function Call
bill = AmountDue(service,calls);
Begins by evaluating each argument
a copy of the value of each is sent to
temporary memory which is created
and waiting for it
the function body determines result
result is returned and assigned to bill
34
int Power ( /* in */ int x,// Base number
/* in */ int n ) // Power to raise base to
// This function computes x to the n power
// Precondition:
// x is assigned && n >= 0 && (x to the n) <= INT_MAX
// Postcondition:
// Function value == x to the n power
{
int result ; // Holds intermediate powers of x
result = 1;
while ( n > 0 )
{
result = result * x ;
n-- ;
}
return result ;
}
35
Syntax Template for
Function Definition
DataType FunctionName ( Parameter List )
{
Statement
.
.
.
}
36
Using bool Type with a Loop
.,,
bool dataOK ; // declare Boolean variable
float temperature ;
.,,
dataOK = true ; // initialize the Boolean variable
while ( dataOK )
{
.,,
if ( temperature > 5000 )
dataOK = false ;
}
Boolean Function
37
A Boolean Function
bool IsTriangle ( /* in */ float angle1,
/* in */ float angle2,
/* in */ float angle3 )
// Function checks if 3 incoming values add up to 180 degrees,
// forming a valid triangle
// PRECONDITION,angle1,angle2,angle 3 are assigned
// POSTCONDITION,
// FCTNVAL == true,if sum is within 0.000001 of
// 180.0 degrees
// == false,otherwise
{
return ( fabs( angle1 + angle2 + angle3 - 180.0 ) < 0.000001 ) ;
}
38
Some Prototypes in Header File < cctype >
int isalpha (char ch);
// FCTNVAL == nonzero,if ch is an alphabet letter
// == zero,otherwise
int isdigit ( char ch);
// FCTNVAL == nonzero,if ch is a digit ( ‘0’ - ‘9’)
// == zero,otherwise
int islower ( char ch );
// FCTNVAL == nonzero,if ch is a lowercase letter (‘a’ - ‘z’)
// == zero,otherwise
int isupper ( char ch);
// FCTNVAL == nonzero,if ch is an uppercase letter (‘A’ - ‘Z’)
// == zero,otherwise
39
Some Prototypes in Header File < cmath >
double cos ( double x );
// FCTNVAL == trigonometric cosine of angle x radians
double exp ( double x );
// FCTNVAL == the value e (2.718,,,) raised to the power x
double log ( double x );
// FCTNVAL == natural (base e) logarithm of x
double log10 ( double x );
// FCTNVAL == common (base 10) logarithm of x
double pow ( double x,double y );
// FCTNVAL == x raised to the power y
40
,What will the function do
with your argument?”
The answer determines
whether your function parameter
should be value or reference
as follows,,,
41
/* in */ value parameter
/* out */ reference parameter
using &
/* inout */ reference parameter
using &
What will the function do with your
argument?
will only use its value
will give it a value
will change its value
IF THE FUNCTION-- FUNCTION PARAMETER IS--
NOTE,I/O stream variables and arrays are exceptions
42
When to Use Value-Returning Functions
1 If it must return more than one value or modify any of the
caller?s arguments,do not use a value-returning function,
2 If it must perform I/O,do not use a value-returning function,
3 If there is only one value returned,and it is Boolean,a
value-returning function is appropriate.
4 If there is only one value returned,and that value will be
used immediately in an expression,a value-returning
function is appropriate.
5 When in doubt,use a void function,You can recode any
value-returning function as a void function by adding an
extra outgoing parameter,
6 If both void and value-returning are acceptable,use the one
you prefer.
43
// *******************************************************
// ConvertDates program
// This program reads dates in American form,mm/dd/yyyy
// from an input file and writes them to an output file
// in American,British,dd/mm/yyyy,and ISO,yyyy-mm-dd
// formats,No data validation is done on the input file.
// *******************************************************
#include <iostream> // for cout and endl
#include <iomanip> // for setw
#include <fstream> // for file I/O
#include <string> // for string type
using namespace std;
void Get2Digits( ifstream&,string& ); // prototypes
void GetYear( ifstream&,string& );
void OpenForInput( ifstream& );
void OpenForOutput( ofstream& );
void Write( ofstream&,string,string,string );
ConvertDates Program
44
ConvertDates Continued
int main( )
{
string month; // Both digits of month
string day; // Both digits of day
string year; // Four digits of year
ifstream dataIn; // Input file of dates
ofstream dataOut; // Output file of dates
OpenForInput(dataIn);
OpenForOutput(dataOut);
// Check files
if ( !dataIn || !dataOut )
return 1;
// Write headings
dataOut << setw(20) <<,American Format”
<< setw(20) <<,British Format”
<< setw(20) <<,ISO Format” << endl << endl;
45
End of main
Get2Digits( dataIn,month ) ; // Priming read
while ( dataIn ) // While last read successful
{
Get2Digits( dataIn,day );
GetYear( dataIn,year );
Write( dataOut,month,day,year );
Get2Digits( dataIn,month ); // Read next data
}
return 0;
}
46
Sample Input Data File
10/11/1975
1 1 / 2 3 / 1 9 2 6
5/2/2004
05 / 28 / 1965
7/ 3/ 19 56
47
Get Year Write
Module Structure Chart
Main
Get Two
Digits
Open For
Output
Open For
Input
someFile someFile dataIn twoChars dataOutyeardataIn
month
day
year
48
void GetYear ( /* inout */ ifstream dataIn,/* out */ string& year )
// Function reads characters from dataIn and returns four digit
// characters in the year string.
// PRECONDITION,dataIn assigned
// POSTCONDITION,year assigned
{
char digitChar ; // One digit of the year
int loopCount ; // Loop control variable
year =,”; // null string to start
loopCount = 1 ;
while ( loopCount <= 4 )
{
dataIn >> digitChar ;
year = year + digitChar ;
loopCount++ ;
}
}
49
Use Stubs in Testing a
Program and Driver
A stub is a dummy function with a very
simple body,often just an output statement
that this function was reached,and a return
value (if any is required) of the correct type,
Its name and parameter list is the same as
a function that will actually be called by the
program being tested.
Driver,A simple main function that is used
to call a function being tested.The use of
driver permits direct control of the testing
process,
50
A Stub for Function GetYear
void GetYear ( /* inout */ ifstream dataIn,
/* out */ string& year )
// Stub to test GetYear function in ConvertDates program.
// PRECONDITION,dataIn assigned
// POSTCONDITION,year assigned
{
cout <<,GetYear was called,Returning \”1948\”.” << endl ;
year =,1948” ;
}
Scope,Lifetime,and More on
Functions
2
Chapter 8 Topics
Local Scope vs,Global Scope of an Identifier
Detailed Scope Rules to Determine which
Variables are Accessible in a Block
Determining the Lifetime of a Variable
Initializations in Declarations
Interface Design
Writing a Value-Returning Function for a Task
Some Value-Returning Functions with
Prototypes in Header Files cctype and cmath
Creating and Using a Module Structure Chart
Stub Testing a Program
3
Scope of Identifier
the scope of an identifier
(or named constant) means
the region of program code where
it is legal to use that identifier for
any purpose
4
Local Scope vs,Global
Scope
the scope of an
identifier that is
declared inside a
block (this includes
function parameters)
extends from the
point of declaration
to the end of the
block
the scope of an
identifier that is
declared outside of
all namespaces,
functions and classes
extends from point of
declaration to the end
of the entire file
containing program
code
5
const float TAX_RATE = 0.05 ; // global constant
float tipRate ; // global variable
void handle ( int,float ) ; // function prototype
using namespace std ;
int main ( )
{
int age ; // age and bill local to this block
float bill ;
,// a,b,and tax cannot be used here
,// TAX_RATE and tipRate can be used
handle (age,bill) ;
return 0 ;
}
void handle (int a,float b)
{
float tax ; // a,b,and tax local to this block
,// age and bill cannot be used here
,// TAX_RATE and tipRate can be used
}
6
Name Precedence
(or Name Hiding)
when a function declares a local identifier
with the same name as a global identifier,
the local identifier takes precedence
within that function
7
Detailed Scope Rules
1 Function name has global scope,
2 Function parameter scope is identical to scope of a
local variable declared in the outermost block of the
function body.
3 Global variable (or constant) scope extends from
declaration to the end of the file,except as noted in
rule 5.
4 Local variable (or constant) scope extends from
declaration to the end of the block where declared,
This scope includes any nested blocks,except as
noted in rule 5.
5 An identifier?s scope does not include any nested
block that contains a locally declared identifier with
the same name (local identifiers have name
precedence).
8
Figure Scope Diagram for
Scope Rules Program
int a1;
char a2;
int main ( )
{
}
void block1 (
{
}
}
void block2 ( )
{
int a1,
char& b2 )
int c1;
int d2;
int a1;
int b2;
while (…)
{ //Block3
}
int c1;
int b2;
9
Name Precedence Implemented
by Compiler Determines Scope
When an expression refers to an identifier,the
compiler first checks the local declarations.
If the identifier isn?t local,compiler works outward
through each level of nesting until it finds an
identifier with same name,There it stops.
Any identifier with the same name declared at a
level further out is never reached.
If compiler reaches global declarations and still
can?t find the identifier,an error message results.
10
Namespace Scope
the scope of an identifier declared in a
namespace definition extends from the
point of declaration to the end of the
namespace body,and its scope includes
the scope of a using directive specifying
that namespace
11
3 Ways to Use Namespace Identifiers
use a qualified name consisting of the
namespace,the scope resolution operator,,
and the desired the identifier
alpha = std,,abs( beta ) ;
write a using declaration
using std::abs ;
alpha = abs( beta );
write a using directive locally or globally
using namespace std ;
alpha = abs( beta );
12
These allocate memory
int someInt ; // for the global variable
int Square (int n) // for instructions in body
{
int result ; // for the local variable
result = n * n ;
return result ;
}
Variable Declarations and Definitions
13
These do NOT allocate memory
int Square (int n) ; // function prototype
extern int someInt ; // someInt is global
// variable defined in
// another file
14
Lifetime of a Variable
the lifetime of a variable is the time
during program execution when an
identifier actually has memory
allocated to it
15
Lifetime of Local Automatic
Variables
their storage is created (allocated)
when control enters the function
local variables are,alive” while
function is executing
their storage is destroyed
(deallocated) when function exits
16
Lifetime of Global Variables
their lifetime is the lifetime of the
entire program
their memory is allocated when
program begins execution
their memory is deallocated when
the entire program terminates
17
Automatic vs,Static Variable
storage for
automatic variable
is allocated at block
entry and
deallocated at block
exit
storage for static
variable remains
allocated throughout
execution of the
entire program
18
By default
local variables are automatic
to obtain a static local variable,you
must use the reserved word static in
its declaration.
19
Static and Automatic
Local Variables
int popularSquare( int n)
{
static int timesCalled = 0 ; // initialized only once
int result = n * n ; // initialized each time
timesCalled = timesCalled + 1 ;
cout <<,Call #,<< timesCalled << endl ;
return result ;
}
20
Initializations in Declarations
First declare a variable,and then,in a
separate statement,assign an initial
value to the variable,
Example,int sum;
sum = 0;
Combine these two statements into one.
Example,int sum = 0;
21
Initializations in
Declarations(cont.)
An automatic variable is initialized to the
specified value each time control enters
the block.
Initialization of a static variable occurs
only once,
Keep an initialization close to the
executable statements that depend on
that variable.
22
Data Flow Determines
Passing-Mechanism
Incoming /* in */ Pass-by-value
Outgoing /* out */ Pass-by-reference
Incoming/outgoing Pass-by-reference
/* inout */
Parameter Data Flow Passing-Mechanism
Interface Design
23
Side Effects
Any effect of one function on another that is not a part
of the explicitly defined interface between them,
COMMUNICATION
INTERFACE
main function
and
other functions
Parameter list
A typical
function
Figure Side Effects
effectsside
24
Global Constant
The values of global constants cannot be
changed while the program is running,no side
effects can occur.
Two advantages to referencing constants
globally:ease of change,and consistency;By
declaring a constant in only one place,we also
ensure that all parts of the program use
exactly the same value.
Not to say that you should declare all
constants globally.
25
Value-Returning Functions
From the caller’s perspective,the main
difference between void functions and value-
returning functions is that a call to a void
function is a complete statement;a call to a
value-returning function is part of an
expression.
From a design perspective,value-returning
functions are used when there is only one
result returned by a function and that result is
to be used directly in an expression.
Function value type,The date type of the
result value returned by a function,
26
Program with Several Functions
Square function
Cube function
function prototypes
main function
27
Value-returning Functions
#include <iostream>
int Square ( int ) ; // prototypes
int Cube ( int ) ;
using namespace std;
int main ( )
{
cout <<,The square of 27 is,
<< Square (27) << endl; // function call
cout <<,The cube of 27 is,
<< Cube (27) << endl; // function call
return 0;
}
28
Rest of Program
int Square ( int n ) // header and body
{
return n * n;
}
int Cube ( int n ) // header and body
{
return n * n * n;
}
29
Prototype for float Function
called AmountDue( ) with 2 parameters
The first is type char,the other is type int.
float AmountDue ( char,int ) ;
This function will find and return the amount due for
local phone calls,A char value?U? or?L? indicates
Unlimited or Limited service,and the int holds the
number of calls made.
Assume Unlimited service is $40.50 per month.
Limited service is $19.38 for up to 30 calls,and $.09 per
additional call.
30
float AmountDue (char kind,int calls) // 2 parameters
{
float result ; // 1 local variable
const float UNLIM_RATE = 40.50,
LIM_RATE = 19.38,
EXTRA =,09 ;
if (kind ==?U?)
result = UNLIM_RATE ;
else if ( ( kind ==?L? ) && ( calls <= 30) )
result = LIM_RATE ;
else
result = LIM_RATE + (calls - 30) * EXTRA ;
return result ;
}
31
#include <iostream>
#include <fstream>
float AmountDue ( char,int ) ; // prototype
using namespace std ;
void main ( )
{ ifstream myInfile ;
ofstream myOutfile ;
int areaCode,Exchange,phoneNumber,calls ;
int count = 0 ;
float bill ;
char service ;
.,,,,,// open files
while ( count < 100 )
{
myInfile >> service >> phoneNumber >> calls ;
bill = AmountDue (service,calls) ; // function call
myOutfile << phoneNumber << bill << endl ;
count++ ;
}
.,,,,,// close files
}
32
To handle the call
AmountDue(service,calls)
MAIN PROGRAM MEMORY
TEMPORARY MEMORY for function to use
Locations:
Locations:
calls bill service
calls result kind
4000 4002 4006
7000 7002 7006
200? ‘ U?
33
Handling Function Call
bill = AmountDue(service,calls);
Begins by evaluating each argument
a copy of the value of each is sent to
temporary memory which is created
and waiting for it
the function body determines result
result is returned and assigned to bill
34
int Power ( /* in */ int x,// Base number
/* in */ int n ) // Power to raise base to
// This function computes x to the n power
// Precondition:
// x is assigned && n >= 0 && (x to the n) <= INT_MAX
// Postcondition:
// Function value == x to the n power
{
int result ; // Holds intermediate powers of x
result = 1;
while ( n > 0 )
{
result = result * x ;
n-- ;
}
return result ;
}
35
Syntax Template for
Function Definition
DataType FunctionName ( Parameter List )
{
Statement
.
.
.
}
36
Using bool Type with a Loop
.,,
bool dataOK ; // declare Boolean variable
float temperature ;
.,,
dataOK = true ; // initialize the Boolean variable
while ( dataOK )
{
.,,
if ( temperature > 5000 )
dataOK = false ;
}
Boolean Function
37
A Boolean Function
bool IsTriangle ( /* in */ float angle1,
/* in */ float angle2,
/* in */ float angle3 )
// Function checks if 3 incoming values add up to 180 degrees,
// forming a valid triangle
// PRECONDITION,angle1,angle2,angle 3 are assigned
// POSTCONDITION,
// FCTNVAL == true,if sum is within 0.000001 of
// 180.0 degrees
// == false,otherwise
{
return ( fabs( angle1 + angle2 + angle3 - 180.0 ) < 0.000001 ) ;
}
38
Some Prototypes in Header File < cctype >
int isalpha (char ch);
// FCTNVAL == nonzero,if ch is an alphabet letter
// == zero,otherwise
int isdigit ( char ch);
// FCTNVAL == nonzero,if ch is a digit ( ‘0’ - ‘9’)
// == zero,otherwise
int islower ( char ch );
// FCTNVAL == nonzero,if ch is a lowercase letter (‘a’ - ‘z’)
// == zero,otherwise
int isupper ( char ch);
// FCTNVAL == nonzero,if ch is an uppercase letter (‘A’ - ‘Z’)
// == zero,otherwise
39
Some Prototypes in Header File < cmath >
double cos ( double x );
// FCTNVAL == trigonometric cosine of angle x radians
double exp ( double x );
// FCTNVAL == the value e (2.718,,,) raised to the power x
double log ( double x );
// FCTNVAL == natural (base e) logarithm of x
double log10 ( double x );
// FCTNVAL == common (base 10) logarithm of x
double pow ( double x,double y );
// FCTNVAL == x raised to the power y
40
,What will the function do
with your argument?”
The answer determines
whether your function parameter
should be value or reference
as follows,,,
41
/* in */ value parameter
/* out */ reference parameter
using &
/* inout */ reference parameter
using &
What will the function do with your
argument?
will only use its value
will give it a value
will change its value
IF THE FUNCTION-- FUNCTION PARAMETER IS--
NOTE,I/O stream variables and arrays are exceptions
42
When to Use Value-Returning Functions
1 If it must return more than one value or modify any of the
caller?s arguments,do not use a value-returning function,
2 If it must perform I/O,do not use a value-returning function,
3 If there is only one value returned,and it is Boolean,a
value-returning function is appropriate.
4 If there is only one value returned,and that value will be
used immediately in an expression,a value-returning
function is appropriate.
5 When in doubt,use a void function,You can recode any
value-returning function as a void function by adding an
extra outgoing parameter,
6 If both void and value-returning are acceptable,use the one
you prefer.
43
// *******************************************************
// ConvertDates program
// This program reads dates in American form,mm/dd/yyyy
// from an input file and writes them to an output file
// in American,British,dd/mm/yyyy,and ISO,yyyy-mm-dd
// formats,No data validation is done on the input file.
// *******************************************************
#include <iostream> // for cout and endl
#include <iomanip> // for setw
#include <fstream> // for file I/O
#include <string> // for string type
using namespace std;
void Get2Digits( ifstream&,string& ); // prototypes
void GetYear( ifstream&,string& );
void OpenForInput( ifstream& );
void OpenForOutput( ofstream& );
void Write( ofstream&,string,string,string );
ConvertDates Program
44
ConvertDates Continued
int main( )
{
string month; // Both digits of month
string day; // Both digits of day
string year; // Four digits of year
ifstream dataIn; // Input file of dates
ofstream dataOut; // Output file of dates
OpenForInput(dataIn);
OpenForOutput(dataOut);
// Check files
if ( !dataIn || !dataOut )
return 1;
// Write headings
dataOut << setw(20) <<,American Format”
<< setw(20) <<,British Format”
<< setw(20) <<,ISO Format” << endl << endl;
45
End of main
Get2Digits( dataIn,month ) ; // Priming read
while ( dataIn ) // While last read successful
{
Get2Digits( dataIn,day );
GetYear( dataIn,year );
Write( dataOut,month,day,year );
Get2Digits( dataIn,month ); // Read next data
}
return 0;
}
46
Sample Input Data File
10/11/1975
1 1 / 2 3 / 1 9 2 6
5/2/2004
05 / 28 / 1965
7/ 3/ 19 56
47
Get Year Write
Module Structure Chart
Main
Get Two
Digits
Open For
Output
Open For
Input
someFile someFile dataIn twoChars dataOutyeardataIn
month
day
year
48
void GetYear ( /* inout */ ifstream dataIn,/* out */ string& year )
// Function reads characters from dataIn and returns four digit
// characters in the year string.
// PRECONDITION,dataIn assigned
// POSTCONDITION,year assigned
{
char digitChar ; // One digit of the year
int loopCount ; // Loop control variable
year =,”; // null string to start
loopCount = 1 ;
while ( loopCount <= 4 )
{
dataIn >> digitChar ;
year = year + digitChar ;
loopCount++ ;
}
}
49
Use Stubs in Testing a
Program and Driver
A stub is a dummy function with a very
simple body,often just an output statement
that this function was reached,and a return
value (if any is required) of the correct type,
Its name and parameter list is the same as
a function that will actually be called by the
program being tested.
Driver,A simple main function that is used
to call a function being tested.The use of
driver permits direct control of the testing
process,
50
A Stub for Function GetYear
void GetYear ( /* inout */ ifstream dataIn,
/* out */ string& year )
// Stub to test GetYear function in ConvertDates program.
// PRECONDITION,dataIn assigned
// POSTCONDITION,year assigned
{
cout <<,GetYear was called,Returning \”1948\”.” << endl ;
year =,1948” ;
}
