Functions
CSIS1117 Computer Programming
Contents
What is a function?
Predefined function provided by C++ library
Mechanism for function calls
User defined function
function prototype
Local variables
Scope of variables
Global variables
c1117 lecture 4
Function
A function is a small program which accomplishes
a specific task.
We can interact (give input and get output) with
functions in our programs for finishing some tasks
C++ libraries provide a lot of predefined functions
that we can use.
For example, sqrt(x) is a function in the cmath library
to compute the square root of x (x is a real number).
c1117 lecture 4
Passing input to
the function sqrt
int
int main(){
main(){
...
...
...
...
sqrt(x);
sqrt(x);
...
...
}}
Our program
double
double sqrt(){
sqrt(){
...
...
}}
In cmath library
Getting output from
the function sqrt
We dont need to write codes for finding the square root
of a number (actually it is difficult to do so), we can call
the function sqrt to help.
c1117 lecture 4
We can call (or invoke) a function using its name
with necessary input (arguments)
At most one value is returned by a function as the
output (return value).
The type of the arguments are specified for each
function
The type of the return value is specified for each
function
The function call sqrt(x) is an expression
We can place a function call in any places where an
expression is expected.
c1117 lecture 4
Function
We usually use the following notation to describe a
function: double sqrt(double x)
double sqrt(double x)
Data type for
the return value
Data type for
the argument
In calling a function, we need to consider:
The name of the function
Type of the return value
Number of arguments
Type of each argument
c1117 lecture 4
sqrt
double
1
double
//
// function
function call
call
double
double val
val == sqrt(9.0)
sqrt(9.0)
We need to specify the library, which contains the
code of the predefined functions, in our program.
e.g. #include <cmath> for using sqrt()
Example: Try to find the roots of a quadratic
equation, ax2+bx+c=0. You can assume that the
two roots exist.
The two roots can be calculated by the following
formula:
-b b2-4ac
roots =
2a
c1117 lecture 4
Example
We need to include the library in
#include
<iostream>
#include <iostream>
using the predefined function
#include
<cmath>
#include <cmath>
int
int main()
main() {{
Invoke the
double
double a,
a, b,
b, c;
c;
sqrt function
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
in cmath
double
double delta
delta == bb ** bb 44 ** aa ** c;
c;
double
double r1
r1 == (-b
(-b ++ sqrt(delta))
sqrt(delta)) // (2
(2 ** a);
a);
double
double r2
r2 == (-b
(-b -- sqrt(delta))
sqrt(delta)) // (2
(2 ** a);
a);
cout
cout <<
<< "the
"the roots
roots are:
are: "" <<
<< r1
r1
<<
<< ",
", "" <<
<< r2
r2 <<
<< endl;
endl;
}}
We can put the function calls in any places where
expressions are expected.
c1117 lecture 4
Flow of control
The execution of the statements in the main
function is from top to bottom.
The flow of control is passed from one statement
to the other.
In evaluating an expression involving function call,
the flow of control actually is suspended in that
statement.
The control is passed to the function (sub-program)
When the sub-program finishes, the control is passed
back to the original statement
The control is resumed from that calling statement.
c1117 lecture 4
Mechanism for function calls
#include
#include <cmath>
<cmath>
int
int main()
main() {{
//
//
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
delta
delta == bb ** bb 44 ** aa ** c;
c;
root1
root1 == (-b
(-b ++ sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
root2
root2 == (-b
(-b -- sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
cout
cout <<
<< "the
"the roots
roots are:
are: "" <<
<< r1
r1
<<
<< ",
", "" <<
<< r2
r2 <<
<< endl;
endl;
}}
11
11
-6
-6
c1117 lecture 4
Main memory
1
1
-6
b
c
25
delta
root1
root2
Command
prompt
10
Mechanism for function calls
#include
#include <cmath>
<cmath>
int
int main()
main() {{
//
//
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
delta
delta == bb ** bb 44 ** aa ** c;
c;
root1
root1 == (-b
(-b ++ sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
root2
root2 == (-b
(-b -- sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
cout<<
cout<< "the
"the roots
roots are:
are: "" <<
<< root1
root1
<<
<< ",
", "" <<
<< root2
root2 <<
<< endl;
endl;
delta
}}
main() is suspended, the
control and the delta are
passed to the sqrt function
c1117 lecture 4
Main memory
1
1
-6
b
c
25
delta
root1
root2
double
double sqrt(double
sqrt(double x){
x){
...}
...}
in cmath library
11
Mechanism for function calls
Main memory
#include
#include <cmath>
<cmath>
1
a
int
int main()
main() {{
//
1
//
b
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
c
-6
delta
=
b
*
b
4
*
a
*
c;
delta = b * b 4 * a * c;
delta
25
root1
root1 == (-b
(-b ++ sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
root2
root2 == (-b
(-b -- sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
2
root1
cout<<
cout<< "the
"the roots
roots are:
are: "" <<
<< root1
root1
root2
<<
<< ",
", "" <<
<< root2
root2 <<
<< endl;
endl;
}}
5
Once sqrt finished, the
double
double sqrt(double
sqrt(double x){
x){
control and the result are
...}
...}
passed back to the original
statement
in cmath library
c1117 lecture 4
12
Mechanism for function calls
Main memory
#include
#include <cmath>
<cmath>
1
a
int
int main()
main() {{
//
1
//
b
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
c
-6
delta
=
b
*
b
4
*
a
*
c;
delta = b * b 4 * a * c;
delta
25
root1
root1 == (-b
(-b ++ sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
root2
root2 == (-b
(-b -- sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
2
root1
cout<<
cout<< "the
"the roots
roots are:
are: "" <<
<< root1
root1
-3
root2
<<
<< ",
", "" <<
<< root2
root2 <<
<< endl;
endl;
delta
}}
5
main is suspended
double
double sqrt(double
sqrt(double x){
x){
nd
again for the 2 call of
...}
...}
sqrt
c1117 lecture 4
in cmath library
13
Mechanism for function calls
#include<cmath>
#include<cmath>
int
int main()
main() {{
//
//
cin
cin >>
>> aa >>
>> bb >>
>> c;
c;
delta
delta == bb ** bb 44 ** aa ** c;
c;
root1
root1 == (-b
(-b ++ sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
root2
root2 == (-b
(-b -- sqrt(delta))/(2*a);
sqrt(delta))/(2*a);
cout<<
cout<< "the
"the roots
roots are:
are: "" <<
<< root1
root1
<<
<< ",
", "" <<
<< root2
root2 <<
<< endl;
endl;
}}
11
11
-6
-6
the roots are: 2, -3
c1117 lecture 4
Main memory
1
1
-6
b
c
25
delta
root1
-3
root2
Command
prompt
14
Some predefined functions
In library cmath -- #include<cmath>
Function
Description
double sqrt(double x)
square root of x
double pow(double x, double y) x to the power of y (ie. xy)
double fabs(double x)
absolute value of x
double ceil(double x)
ceiling, e.g. ceil(3.2)=4
double floor(double x)
floor, e.g. floor(3.2)=3
In library cstdlib -- #include<cstdlib>
int rand()
return a random integer
int abs (int x)
integer absolute value of x
c1117 lecture 4
15
Type casting
Sometimes, we need to convert a value from one
type to another:
int tol_candy, no_of_people;
cin >> tol_candy >> no_of_people;
cout << "The number of candies per person: "
<< tol_candy / no_of_people;
After evaluating the expression, force the type
of the value to the type some_type.
You dont need to include any library for using static_cast.
See casting.cc as an example
c1117 lecture 4
16
Expressions for arguments
Functions require zero, one, or more arguments.
e.g. rand takes no arguments, sqrt takes one and pow
takes two.
An argument can also be an expression. The
expression is evaluated before calling the function.
double
double w,
w, h;
h;
w*w + h*h is evaluated
before calling sqrt
cin
cin >>
>> ww >>
>> h;
h;
cout
cout <<
<< sqrt(w*w
sqrt(w*w ++ h*h)
h*h) <<
<< endl;
endl;
As function call is also an expression, it can be used
in the argument of another function
double
double root1
root1 =(-b
=(-b ++ sqrt(pow(b,2)-4*a*c))/(2*a);
sqrt(pow(b,2)-4*a*c))/(2*a);
c1117 lecture 4
17
User defined functions
The programs youve written so far consists of
only the main function. In fact, you can define
other functions to help organizing your program
Designing functions in programs is the most
important skill in programming.
Advantages of using functions:
Re-usability: Once we implemented a function, we can
invoke it many times in different parts of a program.
Readability: The program becomes more structural.
c1117 lecture 4
18
Example
Consider a problem: Given 3 coordinates (x1, y1),
(x2, y2) and (x3, y3), find the shortest distance
among the 3 pairs of coordinates.
One solution is to calculate the distances of 3 pairs of
coordinates and return the shortest one.
In doing so, we have to write the codes for finding the
distance between a pair of coordinates three times,
even though they are very similar.
Moreover, its easy to make mistake if code is
duplicated.
See closest.cc for an example.
c1117 lecture 4
19
Example
//finding
//finding the
the distance
distance between
between (x1,y1)&(x2,y2)
(x1,y1)&(x2,y2)
double
double dx12,
dx12, dy12,
dy12, dist12;
dist12;
dx12
dx12 == x1
x1 x2;
x2; dy12
dy12 == y1
y1 y2;
y2;
dist12
dist12 == sqrt(dx12
sqrt(dx12 ** dx12
dx12 ++ dy12
dy12 ** dy12);
dy12);
//finding
//finding the
the distance
distance between
between (x1,y1)&(x3,y3)
(x1,y1)&(x3,y3)
double
double dx13,
dx13, dy13,
dy13, dist13;
dist13;
dx13
dx13 == x1
x1 x3;
x3; dy13
dy13 == y1
y1 y3;
y3;
dist13
dist13 == sqrt(dx13
sqrt(dx13 ** dx13
dx13 ++ dy13
dy13 ** dy13);
dy13);
//finding
//finding the
the distance
distance between
between (x2,y2)&(x3,y3)
(x2,y2)&(x3,y3)
...
...
Codes are repeated and its easy to make mistakes.
c1117 lecture 4
20
Defining functions
The natural solution to avoid code duplication is to
define a function.
We can define a function to find the distance of any two
coordinates.
Imagine that if there were such a predefined function
that takes a pair of coordinates and returns the distance
between them, our code could be simplified as:
//finding the
//coordinates
double dist12
double dist23
double dist31
c1117 lecture 4
distances of the 3 pairs of
=
=
=
pair_distance(x1,
pair_distance(x2,
pair_distance(x3,
y1,
y2,
y3,
x2,
x3,
x1,
y2);
y3);
y1);
21
Our next task is to design the function
pair_distance.
A function can be considered as a smaller program
with input & output.
See closest-fun.cc for an example.
The arguments passed to the function is the input
The value/result computed by the function is the output
c1117 lecture 4
22
Structure of a function
return type
function
name
parameters of the function
double
double pair_distance(double
pair_distance(double x1,
x1, double
double y1,
y1,
double
double x2,
x2, double
double y2){
y2){
Body of
double
the
double dx
dx == x1
x1 -- x2;
x2;
double
function
double dy
dy == y2
y2 -- y2;
y2;
double
double distance
distance == sqrt(dx
sqrt(dx ** dx
dx ++ dy
dy ** dy);
dy);
return
return distance;
distance;
}}
Variables can be declared
inside the function.
return statement: return
the value to caller
c1117 lecture 4
23
A function heading consists of a return type, a
function name and a parameters list.
return type: specifying the type of value that the
function will send back to the caller, e.g. double.
function name: name of the function, e.g.
pair_distance
Parameter list: inputs to the function. The parameter
types and number of parameters should be specified.
e.g. pair_distance takes 4 parameters which are
used to store the arguments passed to it.
Each parameter has a type to denote the possible value
that can be stored.
c1117 lecture 4
24
A function is defined uniquely by its heading
(function prototype).
We can put any no. of statements and declare
variables inside the function body.
The value as well as the flow of control, are sent
back to the caller in the return statement
The execution of the function is terminated after
executing (any one of the) return statement.
c1117 lecture 4
25
Understanding function calls
In reading a program with function definitions, we
shall not assume the execution starts from the top
till the bottom of the program file.
In fact, the execution begins at the main function,
no matter how many function definitions are put
before it.
Therefore, to understand the computation of a
C++ program, we need to trace the execution in
main.
c1117 lecture 4
26
Mechanism for function calls
double
double pair_distance(double
pair_distance(double x1,
x1, double
double y1,
y1,
double
double x2,
x2, double
double y2){
y2){
//
//
}}
int
int main()
main() {{
double
double dist12
dist12 == pair_distance(
pair_distance( );
);
}}
Execution starts at the main function
c1117 lecture 4
27
Mechanism for function calls
double
double pair_distance(double
pair_distance(double x1,double
x1,double y1,
y1,
double
double x2,
x2, double
double y2){
y2){
double
double dx
dx == x1-x2;
x1-x2;
double
double dy
dy == y1-y2;
y1-y2;
double
double dist
dist == sqrt(dx*dx
sqrt(dx*dx ++ dy*dy);
dy*dy);
return
return dist;
dist;
}}
pair_distance(double
pair_distance(double px,
px, double
double py,
py,
qx,
qx, double
double qy)
qy)
double
double
double
double
{{ }}
int
int main()
main() {{
double
double dist12
dist12 == pair_distance(
pair_distance( );
);
}}
When executing to a function call, the control is
suspended and passed to the function code.
c1117 lecture 4
28
Mechanism for function calls
double
double pair_distance(double
pair_distance(double
x1,double
x1,double y1,
y1, double
double x2,
x2, double
double y2){
y2){
double
double dx
dx == x1-x2;
x1-x2;
double
double dy
dy == y1-y2;
y1-y2;
double
double dist
dist == sqrt(dx*dx
sqrt(dx*dx ++ dy*dy);
dy*dy);
return
dist;
return
dist;
//in
cmath
library
double
pair_distance(double
px,
//in
cmathpair_distance(double
library
double
px, double
double
}}
py,
qx,
double
sqrt(double
x){
py, double
double
qx, double
double
qy)
double
sqrt(double
x){ qy)
double
{{ }} val;
double
val;
int
int main()
main() {{
return
val;
return
val; }}
double
double dist12
dist12 == pair_distance(
pair_distance( );
);
}}
The control is suspended again and
passed to the predefined function, sqrt.
c1117 lecture 4
29
Mechanism for function calls
double
double pair_distance(double
pair_distance(double
x1,double
x1,double y1,
y1, double
double x2,
x2, double
double y2){
y2){
double
double dx
dx == x1-x2;
x1-x2;
double
double dy
dy == y1-y2;
y1-y2;
double
double dist
dist == sqrt(dx*dx
sqrt(dx*dx ++ dy*dy);
dy*dy);
return
dist;
return
dist;
//in
cmath
library
double
pair_distance(double
px,
//in
cmathpair_distance(double
library
double
px, double
double
}}
py,
qx,
double
sqrt(double
x){
py, double
double
qx, double
double
qy)
double
sqrt(double
x){ qy)
double
{{ }} val;
double
val;
int
int main()
main() {{
return
val;
return
val; }}
double
double dist12
dist12 == pair_distance(
pair_distance( );
);
}}
After the return statement of sqrt is executed, the
result is returned to the caller (pair_distance),
and the control is resumed.
c1117 lecture 4
30
Mechanism for function calls
double
double pair_distance(double
pair_distance(double
x1,double
x1,double y1,
y1, double
double x2,
x2, double
double y2){
y2){
double
double dx
dx == x1-x2;
x1-x2;
double
double dy
dy == y1-y2;
y1-y2;
double
double dist
dist == sqrt(dx*dx
sqrt(dx*dx ++ dy*dy);
dy*dy);
return
double
return dist;
dist; px,
double pair_distance(double
pair_distance(double
px, double
double
py,
}} double
py, double
double qx,
qx,
double qy)
qy)
{{ }}
int
int main()
main() {{
double
double dist12
dist12 == pair_distance(
pair_distance( );
);
}}
After the return statement of pair_distance is
executed, the result is again returned to the caller
(the main function), and the control is resumed.
c1117 lecture 4
31
Viewing execution
We can also picture the execution of a program
using a tree-like diagram.
main()
pair_distance
(4,0,1,3)
sqrt(18)
c1117 lecture 4
pair_distance
(1,3,3,5)
sqrt(8)
pair_distance
(3,5,4,0)
sqrt(26)
32
Function prototype
The order of the functions in a program matters.
The compiler performs the translation by reading the
program from top to bottom.
Errors will be given by compiler if the function is not
defined before it is called.
C++ required that either the complete function
definition or the function prototype appears in the
code before the function is called.
Function prototype: just like the function heading,
specifies the name, return type and the parameter list of
the function.
Function declaration should be ended with a semi-colon.
c1117 lecture 4
33
Function prototype
In writing the prototype, only the types in the parameter
list and the number of parameters are important. The name
of each parameter is optional.
Using prototypes, the function definitions can be placed in
arbitrary order.
Ends with a semi-colon
double
double pair_distance(double
pair_distance(double
x1,double
x1,double y1,
y1, double
double x2,
x2, double
double y2);
y2);
double
double pair_distance(double,
pair_distance(double, double,
double,
double,
double, double);
double);
c1117 lecture 4
34
Function prototype
#include
#include <iostream>
<iostream>
Defining the function
before main().
double
double pair_distance(double
pair_distance(double x1,
x1,
double
double y1,
y1, double
double x2,
x2, double
double y2)
y2)
{{ }}
int
int main()
main()
{{ }}
#include
#include <iostream>
<iostream>
Declare the
function first
by prototype.
Defining the function
after main().
c1117 lecture 4
double
double pair_distance(double
pair_distance(double x1,
x1,
double
double y1,
y1, double
double x2,
x2, double
double y2);
y2);
int
int main()
main()
{{ }}
double
double
double
double
{{ }}
pair_distance(double
pair_distance(double x1,
x1,
y1,
y1, double
double x2,
x2, double
double y2)
y2)
35
Dummy names
The names of the parameters are dummy. They
can always be renamed without affecting the
meaning of the function.
Yet, its better to give meaningful names to
parameters.
These two functions are
double
double pair_distance(double
pair_distance(double px,
px,
the same, but it is more
double
double py,
py, double
double qx,
qx, double
double qy)
qy) readable if meaningful
{{ }}
names are used.
double
double
double
double
{{ }}
c1117 lecture 4
pair_distance(double
pair_distance(double x1,
x1,
y1,
y1, double
double x2,
x2, double
double y2)
y2)
36
Boolean functions
Functions can return more than just number. In
fact, it can return bool, char, string, etc.
bool
bool isValidTriangle(
isValidTriangle( int
int a,
a, int
int b,
b, int
int c){
c){
if
if ((a+b
((a+b << c)
c) &&
&& (b+c
(b+c << a)
a) &&
&& (c+a
(c+a << b))
b))
return
true;
return true;
else
else
return
return false;
false;
}}
//
// aa simpler
simpler version
version
bool
bool isValidTriangle(
isValidTriangle( int
int a,
a, int
int b,
b, int
int c){
c){
return
return (a+b
(a+b << c)
c) &&
&& (b+c
(b+c << a)
a) &&
&& (c+a
(c+a << b);
b);
}}
Ex. Write a boolean function for checking if a year is
a leap year; e.g., bool is_leap(int year);
c1117 lecture 4
37
More examples
Suppose we want to write a program to determine
the grade of a student based on the assignment
scores and exam result.
The grading is based on the overall result.
A: 100-85, B: 84-75, C: 74-65, D: 64-50, F: 49-0
The overall result is composed of 50% from the course
work and 50% from the exam.
Coursework is the average of the 6 assignments.
See grade.cc
c1117 lecture 4
38
Procedural Abstraction
In the previous example, we introduce functions
that are used only once.
They dont serve the code repetition aspect.
The usage of function in this example is to
abstract the details of a computation.
Abstraction, in simple words, means to name a
sequence of operations.
The course work of different courses may be different.
Course XXXX counts only the best 5 assignments.
Course XXXX uses a weighted average of the
assignments.
c1117 lecture 4
39
The computation of the overall result is also put
into a separate function.
How about if the coursework-to-exam ratio is changed
to 40-60?
The main flow of the program does not change.
The changes are localized to the specific function.
Good for maintenance and debugging.
c1117 lecture 4
40
Void function
In some situations, we use functions just for
completing subtasks, without computing or
returning any data.
The return type of this kind of functions is void,
which means nothing.
For a void function, when the flow of control
reaches the end of the function body, the function
finishes and returns the control to the caller.
See change-fun.cc
c1117 lecture 4
41
Return statement
Note that when a return statement executes, the
control is transferred to the caller immediately, i.e.
anything after that return statement will not be
carried out.
Because of the behavior of return, we can omit
some else. See digitword.cc.
Return statement can also be used in void
function.
c1117 lecture 4
42
Arguments Vs parameters
Parameters are listed in the function heading and
are used in the body of the function definition.
Arguments are listed in parentheses after the
function name in a function call, acting as the
input to the function.
C++ is a strong-typing language. The type of
arguments passed to a function must match with
the type of the parameters specified.
Type mismatch between parameters and arguments can
be caught by compiler.
c1117 lecture 4
43
Examples
Which statements will be rejected by the compiler?
Why?
cout
//
cout <<
<< digit_to_word(
digit_to_word( 55 )) <<
<< endl;
endl;
// ???
???
cout
cout <<
<< digit_to_word(
digit_to_word( 22 ** 33 )) <<
<< endl;
endl; //
// ???
???
cout
cout <<
<< digit_to_word(
digit_to_word( 5.0
5.0 )) <<
<< endl;
endl; //
// ???
???
cout
cout <<
<< digit_to_word(
digit_to_word( eleven
eleven )) <<
<< endl;
endl; //
// ???
???
cout
cout <<
<< digit_to_word(
digit_to_word( -2
-2 )) <<
<< endl;
endl;
cout
cout <<
<< digit_to_word(
digit_to_word( 10
10 )) <<
<< endl;
endl;
//
// ???
???
//
// ???
???
digit_to_word(
digit_to_word( 22 );
);
//
// ???
???
c1117 lecture 4
44
Precondition & Postcondition
Precondition specifies the criteria that the
parameters must satisfy.
The caller of the function has to make sure that the
precondition is satisfied.
Postcondition shows the result when the function
finishes execution, provided that the precondition is
satisfied.
//
// pre:
pre: three
three sides
sides s1,
s1, s2,
s2, s3
s3 of
of aa valid
valid triangle
triangle
//
// post:
post: return
return the
the angle
angle opposite
opposite to
to s1
s1
double
double find_angle(double
find_angle(double s1,double
s1,double s2,double
s2,double s3)
s3)
{{ }}
//
// pre:
pre: nn >=
>= 00
//
// post:
post: return
return y,
y, s.t.
s.t. y*y
y*y == nn
double
double sqrt(double
sqrt(double n)
n) {{ }}
c1117 lecture 4
45
Local variables
Should all variables and parameters have different
names?
We can declare and use variables inside the
function body.
These variables are called local variables.
They are local to the function only and cannot be used
outside the function.
In fact, the variables declared in the main function, i.e.
in main(), are local variables of main, which cannot be
used in the user-defined functions.
Parameters of a function are the local variables of the
function.
c1117 lecture 4
46
Local variables
Function declaration
void
void print_output();
print_output();
int
int main(){
main(){
x, y and sum are the
int
local variables of the
int x,
x, y,
y, sum;
sum;
cin
main function. They can
cin >>
>> xx >>
>> y;
y;
only be used inside the
sum
sum == xx ++ y;
y;
main().
print_output();
print_output();
}}
void
void print_output(){
print_output(){
cout
cout <<
<< the
the sum
sum of
of your
your input
input is:
is:
<<
<< sum
sum <<
<< endl;
endl;
}}
Compiler will give error message that the
variable is not declared.
c1117 lecture 4
47
void
void print_output(int
print_output(int
int
int main(){
main(){
int
int x,
x, y,
y, sum;
sum;
cin
cin >>
>> xx >>
>> y;
y;
sum
sum == xx ++ y;
y;
print_output(sum);
print_output(sum);
}}
void
void print_output(int
print_output(int
cout
cout <<
<< the
the sum
sum of
of
<<
<< tt <<
<< endl;
endl;
}}
c1117 lecture 4
t);
t);
The parameter t is a
local variable of the
function print_output.
t){
t){
your
your input
input is:
is:
48
Scope of a variable
Scope of a variable is the portion of the program
that the variable is well-defined and can be used.
The scope of a local variable starts from its
declaration up to the end of the block.
It is not allowed to refer to variables beyond its scope.
A block is delimited by { and }.
Variables declared in an outer block can also be referred
to in the inner block.
We can declare variables with the same name as
long as they have different scopes.
See scope.cc as an example.
c1117 lecture 4
49
x, y and w are
the local
variables of the
function fn, their
scopes are
within fn.
The scope of k is
only within the
inner block.
c1117 lecture 4
int
int fn(int
fn(int x,
x, int
int y){
y){
int
int w;
w;
y, w and k are the
if(
if( xx >> y){
y){
local variables of the
int
k
=
w;
int k = w;
main function, same
...
...
variable names can be
}}
used in different
...
...
}}
scopes.
int
int main(){
main(){
int
int x,
x,
If same variable x is
int
y,
w,
k;
int y, w, k;
declared in the inner
...
...
block, the scope of
if(...){
if(...){
the first x is blocked
int
x;
int x;
in the scope of the
...
...
}}
second x.
}}
50
Global variables
We can declare variables outside any functions.
They can be accessed by any part of the program.
Experience shows that global variables caused a
lot of problem in maintenance.
Program bugs related to global variables are difficult to
trace.
If possible, you should avoid using global variables.
In particular, in the assignments of this course.
c1117 lecture 4
51
Global variables
Global variables are declared outside any functions.
Global variables can be used in any function definitions
that follows the variable declaration.
double
double x;
x;
int
int fn_2(...);
fn_2(...);
int
int fn_1(...)
fn_1(...)
{...}
{...}
int
int y;
y;
int
int main()
main()
{...}
{...}
int
int fn_2(...)
fn_2(...)
{...}
{...}
c1117 lecture 4
Variable x can
be used in fn_1,
fn_2 and the
main function.
Variable y can
only be used in
fn_2 and the
main function.
52
