Chapter Two

Functions

1
Objectives
 This chapter aims for the students to
 Understand basic concepts and need of function
 Declaring and defining a function
 Differentiate predefined and user defined functions
 Understand parameters and arguments of a function
 Understand default arguments and function overload
 Understand static and auto variables (global and local
variables)
 Calling /invoking function by value and reference parameters
 Understand recursive and iterative functions

Chapter2: Functions
2
C++ Functions
● A way to write a program is to first design the method the program
use, and write this method in English – this is what we call algorithm.
● A good plan of attack for designing the algorithm is to break down the
task to be accomplished into a few subtask, decompose subtasks
into smaller subtasks, and so forth.
● This is top-down design or divide and conquer.
● Preserving top-down structure
○ Makes the program easier to understand, easier to change if need
be, and
○ Easier to write, test, debug
● C++ provide facilities to include separate subparts inside of a program
● In other programming languages, it is called subprograms,
procedures, or methods.
● In C++ it is called function
● A function can be defined, either as part of the main program or in a
separate file so that it can be use by several programs

Chapter2: Functions
3
 What is a function?
● A construct for grouping statements together to perform a task.
● A function provides a convenient way of packaging a
computational way, so that it can be used as often as required.
● Therefore, a function is a block of code designed to tackle a
specific problem (task). Eg. withdrawal, deposit, loan, sum,
product, etc
Function Basics
● One of the best ways to tackle a problem is to start with the
overall goal, then divide this goal into several smaller tasks. You
should never lose sight of the overall goal, but think also of how
individual pieces can fit together to accomplish such a goal.
● If your program does a lot, break it into several functions. Each
function should do only one primary task.
Chapter2: Functions
4
 What is a function cont’d
• Functions allow you to modularize a program by separating
its tasks into self-contained units.
• You’ve used a combination of library functions and your
own functions in almost every program you’ve written.
• There are several motivations for modularizing a program
with functions:
• Software reuse. we do not have to define how to read a line of text from
the keyboard—C++ provides this capability via the getline function of the
<string> header.
• Avoiding code repetition.
• Dividing a program into meaningful functions makes the program easier to
test, debug and maintain.
• To promote software reusability, every function should be
limited to performing a single, well-defined task, and the
name of the function should express that task effectively.
Chapter2: Functions
5
What is a function cont’d
C++ functions generally adhere to the following rules.
● Every function must have a name.
● Function names are made up and assigned by the
programmer following the same rules that apply to naming
variables.
● They must be valid identifiers whose size vary per compilers
● All function names have one set of parenthesis immediately
following them.
● This helps you (and C++ compiler) differentiate them from
variables.
● The body of each function, starting immediately after
parenthesis of the function name, must be enclosed by
braces.
● Functions can be predefined or user defined
● Predefined functions require inclusion of header files
which contain their definition
Chapter2: Functions
6
 Predefined functions
• C++ comes with libraries of predefined functions that you can use in your
programs. Example:
• sqrt function is a predefined function that calculates the square
root of a number.
• You can use a function call directly in a cout statement, as in the
following:
cout << "The side of a square with area " << area
<< " is " << sqrt(area); or
cout<<sqrt(9); // which produces 3
sqrt() is defined in the heder file cmath, thus we need to include it:
#include <cmath>
• A few predefined functions are shown (next slide);
• Notice that the absolute value functions abs and labs are in the library with
header file cstdlib, so any program that uses either of these functions must
contain the following directive:
#include <cstdlib>
• Next slide shows sample of predefined functions along with library headers
Chapter2: Functions
7
Chapter2: Functions 8
Random number generator
• Games and simulation programs often require the generation of
random numbers.
• C++ has a predefined function to generate pseudorandom numbers.
• A pseudorandom number is one that appears to be random but is
really determined by a predictable formula.
• For example, here is the formula for a very simple pseudorandom
number generator that specifies the ith random number Ri based
on the previously generated random number Ri-1:
• Ri = (Ri−1 x 7) % 11
• Let’s set the initial “seed,” R0 = 1. The first time we fetch a “random”
number
• we compute R1 with the formula:
• R1 = (R0 x 7) % 11 = (1 x 7) % 11 = 7 % 11 = 7
• The second time we fetch a “random” number we compute R2 with:
• R2 = (R1 x 7) % 11 = (7 x7) % 11 = 49 % 11 = 5
• The third time we fetch a “random” number we compute R3 with:
• R3 = (R2 x 7) % 11 = (5 x 7) % 11 = 35 % 11 = 2
• and so on.
Chapter2: Functions
9
Random number generator
• C++ has a predefined function called rand(), defined in cstdlib header
library, generates random rather pseudorandom numbers between 0
and RAND_MAX
• Every time the calling program is run, the same number is displayed; this is because
srand(1) is used by default
• To vary the random number sequence every time the program is
executed, we can seed the random number generator with the time of
day:
• Call srand(time(0)); before rand() is called
• Invoking the predefined function time(0) returns the number of seconds
that have elapsed since January 1, 1970 on most systems. The time
function requires you to include the ctime library.
#include <cstdlib>
#include <ctime>
...
srand(time(0));
Calling rand() seems more random
• To randomly generate integers 1 to 6, use rand()%+1
Chapter2: Functions
10
User defined functions
Declaring, defining and calling functions
Declaring function (also called function prototype)
● It is an interface that specifies how a function may be used.
● A function declaration tells you all you need to know to write a call
to the function. A function declaration is required to appear in
your code prior to a call to a function whose definition has not yet
appeared. Function declarations are normally placed before the
main part of your program.
● It consists of three entities:
● The function return type. This specifies the type of value the
function returns. Eg. int, char, double, etc
● A function which returns nothing should have a return type void.
● The function name. this is simply a unique identifier
• The function parameters (also called its signature). This is a set of zero or
more typed identifiers used for passing values to and from the function.
• Eg. int withdrawal(float amt);

Chapter2: Functions
11
User defined functions cont’d
int maximum(int x, int y, int z); // function prototype
• This is a function prototype, which describes the maximum function
without revealing its implementation.
• A function prototype is a declaration of a function that tells the compiler
the function’s name, its return type and the types of its parameters.
• This function prototype indicates that the function returns an int, has the
name maximum and requires three int parameters to perform its task.
• The portion of a function prototype that includes the name of the function
and the types of its arguments is called the function signature or simply
the signature.
• The function’s return type is not part of the function signature.
• Notice that the function prototype is the same as the first line of the
corresponding function definition, but ends with a required semicolon.
• Parameter names in function prototypes are optional (they’re ignored by
the compiler), but many programmers use them for documentation
purposes.
• Declaring function parameters of the same type as int x, y instead of int x,
int y is a syntax error—a type is required for each parameter in the
parameter list.
Chapter2: Functions
12
User defined functions cont’d
• Returning Control from a Function to Its Caller
• When a program calls a function, the function performs its task, then
returns control (or a value) to the point where the function was called.
• In a function that does not return a result (i.e., it has a void return type),
control returns when the program reaches the function-ending right brace.
You also can explicitly return control to the caller by executing the
statement
return;
• A function prototype is required unless it is defined before being used.
• When you use a standard library function like sqrt, you do not have
access to the function’s definition, therefore it cannot be defined in your
code before you call the function. Instead, you must include its
corresponding header (<cmath>), which contains the function’s prototype
and definition.
• If a function is defined before it’s called, then its definition also serves as
the function’s prototype, so a separate prototype is unnecessary.
• If a function is called before it’s defined, and that function does not have a
function prototype, a compilation error occurs.
Chapter2: Functions
13
Syntax for function declaration and definition

Chapter2: Functions 14
Functions definition
● A function definition describes how the function
computes the value it returns.
● A function definition consists of two parts:
● Function header (prototype) & function body.
● Function body. The brace of a function contains the
computational steps (statements) that computerize the
function.
● Always provide function prototypes, even though it’s
possible to omit them when functions are defined
before they’re used.
● Providing the prototypes avoids tying the code to the order in
which functions are defined (which can easily change as a
program evolves)

Chapter2: Functions
15
Calling a function
● Using a function involves ‘calling’ it.
● Calling a function means making the instruction of the function to
be executed.
● A function call consists of the function name followed by the call
operator brackets ‘()’, inside which zero or more comma-separated
arguments appear.
● The number and type of arguments should match the number of
function parameters.
● Each argument is an expression whose type should match the type
of the corresponding parameter in the function interface
(prototype).
● When a function call is executed,
○ the arguments are first evaluated and their resulting values are
assigned to the corresponding parameters.
○ The function body is then executed.
○ Finally the return value (if any) is passed to the caller.

Chapter2: Functions
16
Calling a function cont’d
● A function call in C++ is like a detour on a highway.
● Imagine that you are traveling along the “road” of the
primary function called main().
● When you run into a function-calling statement, you
must temporarily leave the main() function and execute
the function that was called.
● After that function finishes (its return statement is
reached), program control returns to main().
● In other words, when you finish a detour, you return to
the “main” route and continue the trip. Control
continues as main() calls other functions
Chapter2: Functions
17
Calling a function cont’d
• A function is invoked by a function call, and when the called
function completes its task, it either returns a result or simply
returns control to the caller.
• An analogy to this program structure is the hierarchical form
of management

Chapter2: Functions
18
Calling a function cont’d
• A boss (similar to the calling function) asks a worker (similar
to a called function) to perform a task and report back (i.e.,
return) the results after completing the task.
• The boss function does not know how the worker function
performs its designated tasks.
• The worker may also call other worker functions, unknown to
the boss.
• This hiding of implementation details promotes good software engineering.
• The boss function divides the responsibilities among the
worker functions, and worker1 acts as a “boss function” to
worker4 and worker5 (previous slide)
• The relationship does not need to be hierarchical, but often it
is, which makes it easier to test, debug, update and maintain
programs.
Chapter2: Functions
19
Lets have another very simple function
example:
#include<iostream>
Using namespace std;
void starLine(); //function prototype
//func
int main()
definition
{ starLine(); //Calling the function with a
void starLine()
name starLine
{
cout<< “Data type Range” << endl;
for(int
starLine();
j=0;j<45;j++)
cout<< “char -128 to 127” <<endl
cout<< “*”;
<< “short -32,768 to 32,767” <<endl
cout<<endl;
<< “ int system dependent” <<endl
}
<< “long -2,147,483,648 to
2,147,483,647” << endl;
starLine();
return 0; }

Chapter2: Functions 20
Given the next program, which function is the
calling function and which is the called function?

#include<iostream>
void nextMsg();
int main()
{
cout<< “Hello!\n”;
nextMsg();
return 0;
void nextMsg() {
}
cout<< “GoodBye!\n”;
return;
}

Chapter2: Functions 21
Function parameters and arguments
● The formal parameters (is used as a kind of blank, or
place holder, to stand in for the argument)
● are list of variables used by the function to perform its
task, and
● the arguments passed to the function during calling of a
function are values sent to the function.
● The arguments of function calling can be using either of
the two supported styles in C++: passing by value or
passing by reference.
Passing by value:
● A value parameter receives a copy of only the value of
the argument passed to it. As a result, if the function
makes any changes to the parameters, this will not
affect the argument. For instance (see next slide)
Chapter2: Functions
22
#.....
int main()
{ int x = 10;
Foo(x);
cout<< “x = ”<<x<< “\n”;

return 0;
}

void Foo(int num)

{ num = 0;
cout<< “num = ” << num << “ \n”;
}

Chapter2: Functions 23
Pass by value
● The single parameter of Foo is a value parameter.
● As far as this function is concerned, num behaves just
like a local variable inside the function.
● When the function is called and x passed to it, num
receives a copy of the value of x.
● As a result, although num is set to 0 by the function, this
does not affect x.
● The program produces the following output:
○ Num = 0
○ x = 10
● Passing arguments in this way, where the function
creates copies of the arguments passed to it is called
passing by value Chapter2: Functions 24
Pass by reference
● A reference parameter, on the other hand,
receives the argument passed to it and
works on it directly. Any change made by
the function to a reference parameter is in
effect directly applied to the argument.
● Passing parameters in this way is called
pass-by-reference
● Taking the same example with pass by
reference (next slide)

Chapter2: Functions 25
#.....
int main()
{
int x = 10;
Foo(x);
cout<< “x = ”<<x<< “\n”;

return 0;
}
void Foo(int & num)
{
num = 0;
cout<< “num = ” << num << “ \n”;
}
Chapter2: Functions 26
Pass by reference cont’d
● The parameter of Foo is a reference parameter. Num
will correspond to x for this specific program as it x is
sent by its reference and not its value.
● Any change made on num will be effected to x. Thus,
the program produces the following output:
num = 0
x=0
● Suppose you have pairs of numbers in your program
and you want to be sure that the smaller one always
precedes the larger one.
● To do this, you call a function, order(), which checks two
numbers passed to it by reference and swaps the
originals if the first is larger than the second.
Chapter2: Functions 27
#.......
void order(int &, int &);
int main() {

int n1 = 99, n2=11; void order(int &num1,int &num2)

int n3 = 22, n4=88; {
if(num1 > num2)
order(n1,n2);
{
order(n3,n4); int temp=num1;
cout<< “n1=”<<n1<<endl; num1 = num2;
num2 = temp;
cout<< “n2=”<<n2<<endl;
}
cout<< “n3=”<<n3<<endl; }
cout<< “n4=”<<n4<<endl;
return 0; }
Output??? Chapter2: Functions 28
Pass by reference cont’d
● Using reference arguments in this way is a sort of
remote control operation.
● The calling program tells the function what variables
in the calling program to operate on, and the
function modifies these variables without ever
knowing their real names.

Chapter2: Functions 29
Global vs local variables
● Everything defined at the program scope level (outside
functions) is said to have a global scope.
○ Eg.

int year = 1994; //global variable

int max( int, int ); //gloabal funcrion
int main ( void )
{
//…
}
● Global variables are visible (“known”) from their point of
definition down to the end of the program.
Chapter2: Functions 30
Local variables
● Each block in a program defines a local scope.
● Thus the body of a function represents a local scope.
● The parameters of a function have the same scope as the
function body.
● Variables defined within a local scope are visible to that
scope only.
● Hence, a variable need only be unique within its own scope.
Local scopes may be nested, in which case the inner scope
overrides the outer scopes
int xyz; // xyz is global
void Foo ( int xyz ) // xyz is local to the body of Foo
{ if(xyz > 0){
double xyz; // xyz is local to this block
…
Chapter2: Functions
}
31
Scope operator
● Because a local scope overrides the global scope,
having a local variable with the same name as a
global variable makes the latter inaccessible to
the local scope.
Eg

int num1;
void fun1(int num1)
{
//…
}
Chapter2: Functions 32
Scope operator cont’d
Solution???
● Use scope operator ‘::’ which takes a global entity as
argument.
int num1 = 2;//global variable

void fun1(int num1) {

//…

num1=33; //local variable

cout<<num1; // the out put will be 33

// why? Because local variable overrides global variable

cout<<::num1; //the out put will be 2 which is the global

if(::num1 != 0)//refers to global num1

//… Chapter2: Functions 33

Automatic vs static variables
• describe what happens to local variables
when a function returns to the calling
procedure.
• By default, all local variables are
automatic.
○ meaning are erased when the function
Eg. usemain()
ends. They prefix auto
{
int i;
auto float x;
…
}
Chapter2: Functions 34
Automatic vs static variables cont’d
● The opposite of an automatic is a static variable.
● All global variables are static and
● all static variables retain their values.
● Therefore, if a local variable is static, it too retains its
value when its function ends -in case this function is
called a second time.
● static is a keyword to declare a static variable.
● Static variables can be declared and initialized within the
function, but the initialization will be executed only once
during the first call.
● If static variables are not initialized explicitly, they will be
declared to 0 automatically
Chapter2: Functions 35
void my_fun(){
static int num;
int num2=9;
static int count = 2;
count*=5; num+=4; void main () {
num2+=2; my_fun();
cout<<“num= “<<num my_fun();
<<”, count= “<<count my_fun();
<<”, num2= “<<num2; }//observe the result
<<endl; //each time my_fun()
} is //called

● N.B. if local variables are static, their values

remain in case the function is called again.
Chapter2: Functions 36
inline functions

● Suppose that a program frequently requires finding the

absolute value of an integer quantity.
● For a value denoted by n, this may be expressed as:
(n > 0 ? n : -n)
● Solution? to define it as a function:
int Abs ( int n ){
return n > 0 ? n : -n; }
● The disadvantage of the function version  substantial
overhead
■ Extra time and space used to invoke function, pass parameters,
allocate storage for its local variables, store the current variable,
etc.
Chapter2: Functions 37
● Solution??? defining as an inline function.
● The effect of this is that when Abs is called, the compiler, instead
of generating code to call Abs, expands the program body and
substitutes the body of Abs in place of the call.

inline int Abs ( int n )

{
return n > 0 ? n : -n;
}
void main ( )
{
cout<<Abs(-10); //n>0?n:-n
}

Chapter2: Functions 38
inline functions cont’d

● Not every function can be inlined. Some typical

reasons why inlining is sometimes not done include:
■ the function calls itself, that is, is recursive
■ the function contains loops such as for(;;) or while()
■ the function size is too large
● Another good reason to inline is that you can
sometimes speed up your program by inlining the
right function.
● Most of the advantage of inline functions comes from
avoiding the overhead of calling an actual function.
● Concerning inline functions, the compiler is free to
decide whether a function qualifies to be an inline
function. If the inline function is found to have larger
chunk (amount) of code, it will not be treated as an
inline function, butChapter2:
as like other normal functions.
Functions 39
 Default arguments and function overload
● C++ has two capabilities that regular C doesn’t have. Default
arguments and function overloading.
● Default argument is a programming convenience which
removes the burden of having to specify argument values for
all function parameters.
● You might pass a function an error message that is stored in
a character array, and the function displays the error for a
certain period of time. The prototype for such a function can
be this:

Void pr_msg(char note[]);

● Therefore, to request that pr_msg() display the line ‘Turn
printer on’, you call it this way:
● Pr_msg(“Turn printer on”);
Chapter2: Functions 40
Default arguments and function overload …

● As you write more of the program, you begin to realize

that you are displaying one message-for instance, the
‘Turn printer on’ msg-more often than any other
message.
● Instead of calling the function over and over, typing
the same message each time, you can set up the
prototype for pr_msg() so that it defaults to the ‘turn
printer on’ message in this way:
void pr_msg(char note[] = “Turn printr on”);
● This makes your programming job easier. Because you
would usually want pr_msg() to display ‘turn printer
on’, the default argument list takes care of the
message and you don’t have
Chapter2: to pass the message
Functions 41
Default arguments and function overload …
E.g.: Let us develop part of the program with default arguments.
void Add_Display(int x=10, int y=20, int z=30) {
cout<< (x+y+z); }
void Mult_Display (int x, char y) {
cout<< (x*y); }
void main() {
int a=40, b=50, c=60;
Mult_Display(‘A’, 5);//prints 325 (i.e. 65*5)
Add_Display(a,b,c); //will print 150 (ie 40+50+60)
Add_Display(a,b); //will print 120 (ie 40+50+30)
Add_Display(a); //will print 90 (ie 40+20+30)
Add_Display(); //will print 60 (ie 10+20+30)
Mult_Display(a,b); //will print 2000 (40*50)
//Mult_Display(a); //error, too few arguments
//Mult_Display() //is invalid as there is no default for }
Chapter2: Functions
42
Default arguments and function overload …

//parameters with default should always be at the

//right side of function declaration
void Mult_Dispaly (int x, int y=70, int z)

{ cout<< (x*y*z);

}
//thus the following function definition will be correct

void Mult_Dispaly (int x, int z, int y=70) {

cout<< (x*y*z);

}
Chapter2: Functions 43
Overloaded functions

● Unlike C, C++ lets you have more than one

function with the same name.
● Functions with the same name are called
overloaded functions.
● C++ requires that each overloaded
functions differ in its argument list.
● Overloaded functions enable you to have
similar functions that work on different types
of data.
Chapter2: Functions 44
Overloaded functions cont’d

● Suppose that you write a function that return the

absolute value of what ever number you passed to it:
int iAbs(int i) {
if(i<0)
return (i*-1);
else
return (i); }
float fAbs(float x) {
if(x<0.0)
return (x * -1.0);
else
return (x); }

Chapter2: Functions 45
Overloaded functions cont’d
• N.B: if two or more functions differ only in
their return types, C++ can’t overload them.
• Two or more functions that differ only in their
return types must have different names and
can’t be overloaded
• without using overloading, you have to call the
function as:
int ans = iAbs(weight);//for int arguments
float ans = fAbs(weight);//for float arguments
• But with overloading, the above code can be
used as shown (next slide)

Chapter2: Functions
46
int abs ( int i ); int Abs(int i)
float Abs ( float x ); {
int main ( ) if(i<0)
return i*-1;
{ else
… return I;
ians = Abs(i);//calling abs }

with int arguments

fans = Abs(p);//calling abs float Abs(flaot x)
{
with float arguments if(x<0.0)
… return x*-1.0;
} else
return x;
}

Chapter2: Functions
47
 Recursion

● A function which calls itself is said to be recursive function.

● Recursion is a general programming technique applicable to
problems which can be defined in terms of themselves.
● Take the factorial problem, for instance which is defined as:

○ factorial of 0 is 1

○ factorial of a positive number n is n time the factorial of

n-1.

unsigned int factorial(unsigned int n )

return n = = 0 ? 1 : n * factrial ( n-1);

}
Chapter2: Functions 48
For n set to 4, the following figure shows the recursive
call:

Factorial ( 4 )

24
4 * Factorial ( 3 )

6
3 * Factorial ( 2 )

2
2 * Factorial ( 1 )

1 1

Chapter2: Functions 49
Chapter2: Functions 50
Recursion cont’d

● The stack frames for these calls appear sequentially

on the runtime stack, one after the other.
● Stack frame – The section of memory where the local
variables, arguments, return address and other
information of a function are stored, is called stack
frame or activation record.
● A recursive function must have at least one
termination condition which can be satisfied.
● Otherwise, the function will call itself indefinitely
until the runtime stack overflows.

Chapter2: Functions 51
Recursion cont’d
• The three necessary components in a recursive method
are
 A test to stop or continue the recursion
 An base case or end case that terminates the
recursion
 A recursive call(s) that continues the recursion
• let us implement two more mathematical
functions using recursion
• e.g the following function computes the sum of the first
N positive integers 1,2,…,N.
• Notice how the function includes the three necessary
components of a recursive method (next slide)
Chapter2: Functions 52
 Recursion cont’d
int sum(int N) {
if(N==1)
return 1;
else
return N+sum(N-1);
}
• The last method computes the exponentiation A n where A is a real number and N is
a positive integer. This time, we have to pass two arguments. A and N. the value of
A will not change in the calls, but the value of N is decremented after each recursive
call.
float expo(float A, int N) {
if(N==1)
return A;
else
return A * expo(A,N-1);
}
Chapter2: Functions
53
Recursion cont’d

● Try to use a recursive function call to solve the

Fibonacci series. The Fibonacci series is :
 0,1,1,2,3,5,8,13,21,…
● The recursive definition of the Fibonacci series
is as follows
○ Fibonacci (0) =0
○ Fibonacci (1) =1
○ Fibonacci (n) =Fibonacci (n-1) +Fibonacci (n-2);

○ Next slide show the logic graphically

Chapter2: Functions
54
Chapter2: Functions 55
 Recursion vs Iteration
● Both iteration and recursion are based on control structure.
○ Iteration uses a repetition structure (such as for, while, do…while) and
○ recursive uses a selection structure (if, if else or switch).
● Both iteration and recursion involve repetition: Iteration explicitly uses a
repetition structure; recursion achieves repetition through repeated method
calls or function calls.
● Iteration and recursion each involve a termination test: Iteration terminates
when the loop-continuation condition fails; recursion terminates when a
base case is recognized
● Both iteration and recursive can execute infinitely-an infinite loop occurs with
iteration if the loop continuation test become always true or loop termination
condition cannot be met. And infinite recursion occurs if the recursion step
doesn’t reduce the problem in a manner that converges on a base case.
● Recursion has disadvantage as well. It repeatedly invokes the mechanism,
and consequently the overhead of method calls. This can be costly in both
processor time and memory space. Each recursive call creates another copy
of the method (actually, only the function’s variables); this consumes
considerable memory. Chapter2: Functions 56
Recursion vs iteration cpnt’d
● N.B: Use recursion if:
○ A recursive solution is natural and easy to
understand
○ A recursive solution doesn’t result in
excessive duplicate computation.
○ the equivalent iterative solution is too
complex and
○ of course, when you are asked to use one in the
exam!!

Chapter2: Functions 57
End of Chapter 2

Chapter2: Functions 58