1

FUNDAMENTALS OF
PROGRAMMING

Lecture 8: FUNCTIONS

DEPARTMENT OF COMPUTER ENGINEERING

COLLEGE OF E&ME
Functions

Output = f(a,b)
Motivation for using Functions
 The divide-and-conquer approach
 Itmakes program development more manageable by
constructing programs from small, simple pieces.

 Software reusability
 Usingexisting functions as building blocks to create new
programs.
 Avoids repeating code.
 Dividing a program into meaningful functions makes
the program easier to debug and maintain.
Functions
 Every function should be limited to performing a
single, well-defined task
 E.g sum and difference operations should make 2
functions, not one.
 Name of the function should be sensible. Such
functions make programs easier to write, test,
debug and maintain.
 Callingyour functions “func” or “A” will make your
program listing difficult to understand and follow.
Functions
 Any portion of the code that carries out a specific
task or is to be repeated several times can be
converted into a function.
 For example, the summing operation takes 2 inputs
and returns their sum as output.
 sum() function can be called every time to calculate the
sum
 Pre-Defined Functions
 Programs written by
 combining new functions with “prepackaged”
functions in the C++ standard library.
 The standard library provides a rich collection of
functions.
 Input/output(getline, read etc.)
 Common mathematical calculations (pow, sqrt, exp, etc.)
 String manipulations(strcpy, strcat, etc.)
 Many more

6
 Function Call

 Functions are invoked by a function call

 A function call specifies the function name and provides
information (as arguments) that the called function needs
 Boss to worker analogy:
A boss (the calling function or caller) asks a worker (the
called function) to perform a task and return (i.e., report
back) the results when the task is done.

7
 Function Definitions
 Function definitions
 Only written once
 These statements are hidden from other functions.

 Boss to worker analogy:

The boss does not know how the worker gets the job done; he
just wants it done

8
 Math Library Functions

 Math library functions

 Allow the programmer to perform common mathematical calculations
 Are used by including the header file <math.h>
 Functions called by writing
functionName (argument)
 Example
cout << sqrt( 900.0 );
 Calls the sqrt (square root) function. The preceding statement would
print 30
 The sqrt function takes an argument of type double and returns a
result of type double, as do all functions in the math library

9
 Math Library Functions

 Function arguments can be

 Constants
sqrt( 4 );
 Variables
sqrt( x );
 Expressions
sqrt( sqrt( x ) ) ;
sqrt( 3 - 6x );

10
Components of a Function
 Prototype or Function Declaration
 Function Call
 Function Definition or Function Body
Preprocesssor lines

function1 prototype; //function prototype

function2 prototype;

int main( )
{
call function1(); //function call
call function2();
……
}

int function1( ) //function definition

{ //function body
……
}

int function2( )
{
……
Functions
 Function Prototype ( Declaration)
 Tells
the compiler that a function of this kind is defined
somewhere in the program
 Function Call
 Takes the program control to the called function
 Function Header and Body (Definition)
 Containsthe body of the function i.e. all the commands
that make up the function
Example
#include <iostream>
using namespace std;
void sum(void); Declaration
int main()
{
sum(); Function Call
return 0;
}
void sum(void) Definition or Body
{
float first, second;
cin >> first >>second;
cout << first + second;
}
Types of Functions
 Functions with no input and no output
 Functions with input but no output
 Functions with no input but output
 Functions with input and output
Functions

Input ARGUMENT RETURN value

Function

void function (void)

Fns with no Input/Output

Function

void function (void)

 A void function does not return any value (no output)

 It does not take any parameters
 It performs a specific task .
Fns with no Input/Output
 It may use data stored internally within the function
body or only display the number of times the
function is called

 An example is a Beep( ) function (inbuilt) that sounds

an audible alarm to alert the user. It needs no input
parameters and returns no o/p.
 Example – No Input/Output
void errormessage(void); // prototype

int main()
{
int x, a=0;
while(a<10)
{
cout << "press 7";
cin >> x;
if(x!=7)
errormessage(); // function call
a++;
}
return 0;
}

void errormessage(void) // function header and body

{
cout <<" You have entered wrong key";
}
Fns with Input but no Output

Function
void function (int)

 Such a function does not return any value.

 However, it takes input parameters
 It performs a specific task.
 For example, it may perform some operation on the
input data and simply display it on the screen.
Example – Input but no Output
void square(float, int); // prototype

int main(void)
{
float x, y;
int num;
x = 4.0;
y=1.0;
square(y, num); //function call
return 0;
}

void square( float a, int digit) // function header and body

{
float b;
b = a * a;
cout <<"The answer "<<b;
}
Fns with Output but no Input

Function
int function (void)

 Such a function returns a value

 However it does not takes input parameters
 It performs a specific task.
 For example, it may take input values from user inside the
function body and return the result of the operation to
main().
 Example – Output but No Input
float sum(void); // prototype

int main (void)

{
float add;
add=sum(); // function call
cout <<"sum = " <<add;
return 0;
}

float sum(void) // function header and body

{
float first, second, ans;
cin >> first >> second;
ans = first + second;
return ans;
}
Fns with both Input and Output

Function
int function (int)

 Such a function returns a value

 It also takes input parameter(s)
 It performs a specific task.
 For example, it may take input values from main() and
return the result of the operation to main().
Example – Both Input and Output
float sum (float, float); // prototype

int main (void)

{
float first, second, add;
first = 23.45;
second = 87.555;
add=sum (first, second); // function call
cout <<"sum = " << add;
return 0;
}

float sum (float x, float y ) //function header and body

{
float a;
a = x+y;
return a;
}
Function Parameters
 Parameters are variables and expressions that are
used to pass information to and from functions.
 A formal parameter is a variable declared in a function
heading.
 An actual parameter is a variable (or expression) listed in
function call.
int our_formula(int,int); // prototype

int main()
{
int a,b,c;
Actual Parameters
a = 5;
b = 7;
c = our_formula(a,b); // function call
cout <<"result = “ << c;
}

int our_formula(int x,int y) // function body

{
int c; Formal Parameters
c = 2 * x + 3 * y;
return(c);
}
Some General Rules
 The function is given a name and called (or invoked)
using this name each time the task is to be
performed within the program.
 The function that is being called is often referred to
as the called function.
 The program that calls a function is referred to as
the calling program or calling function.
 The execution transfers from the calling function to
the called function.
int main() void func(void)
{ dd { ddd dd
func(); cin>>a;
cin>>a; cin>>b;
……… ………..
………. …………
}ddddddd }dddddddddd
Some General Rules
 Function name is followed by a number of arguments in
brackets ().
 If the called function is returning a value, then it is used
as a right hand side value of an expression.
 Body of the function must be enclosed within braces {}
 A function can take as many arguments as you want
 A function can only return ONE value!
 When the end brace(}) of that called function is
reached, execution returns to a point immediately after
the place at which the function was called.
 int main()
{ dd
x=func();
cin>>a;
………
……….
}ddddddd

int func(void)
{ ddd dd
cin>>a;
cin>>b;
………..
return a;
}dddddddddd
Function Signatures
 Portion of function prototype that includes the name
of the function and the types of its arguments is
called the function signature.
 Function in the same scope must have unique
signatures.
Variables and Storage Classes
 The storage class of a variable determines which
parts of the program can access it (scope)and how
long it stays in existence
(lifetime)
 Types of variables
 Automatic or Local
 Global or External Variable
 Static
Scope and Life Time of Variable
 Life Time
 The time b/w creation and destruction of variable is
called the life time or duration. Lifetime of a variable is
limited to save memory.
 Scope
 Scope refers to blocks of code within which variables
are visible. Scope limits visibility to improve
organization and modularity of the program.
Scope
 The life-time of variables exists within the variable’s
scope.
 After declaration, a variable can be referenced
anywhere within its scope.
 Every set of braces has its own scope, and can contain
local variables.
 The moment the set of braces in which a variable was
declared ends, the variable goes out of scope, i.e. it
can no longer be referenced as an identifier.
Scope
 The program erases variables that have gone out of
scope from memory, i.e. their life-time ends.
 The scope of arguments to a function is the entire
function body.
 No two variables may share the same name within a
scope.
Scope
 Example: A variable declared in the first line of a
function can be used anywhere in the function, but
nowhere outside of it.
 The moment the function exits, the variable ceases to
exist in memory, i.e. its scope and lifetime end.
Automatic or Local Variables
 Variables defined within the function body (or a set
of braces) are called automatic or local variables.
 Properties
 It is most commonly used.
 It is not created until the function in which it is defined is
called.
Automatic or Local Variables
 Life Time
 When control is returned to the calling program, these
variables are lost. Life time is equal to the life of
function.
 Scope
 Automatic variable are only visible with in function, they
can only be accessed within the function in which they
are created.
 Example (Local Variables)
#include <math.h>

void squareroot(float);

int main(void)
{
float x;
x = 4.0;
squareroot(x); //function call
}

void squareroot( float a)

{
float y=0;
y = sqrt(a);
cout <<"The answer = " << y <<endl;
}
External or Global Variables
 Variable defined outside the function. Normally it is
declared before main function.
 Properties
 Every function can access global variables.
 Thus, any function can change the values of
global variables.
 This creates organizational problems
Global Variables
 Global variables should generally be
avoided unless necessary.
 It is a good practice to use
::globalvariable_name for using a global
variable.
 eg, if ‘a’ is the global variable, write ‘::a’
where-ever ‘a’ is used in the code
Global Variables
 Life Time
 is equal to the life of program.
 Scope
 It is visible to all the function in a program.
 Example (Global Variables)
float sum(); // prototype
float first, second;

int main(void)
{
::first = 23.45;
::second = 87.555;
cout <<"sum = “ << sum();
return 0;
}

float sum()
{
return ::first + ::second;
}
Static Local Variables
 Static variable remembers and maintains its value
even after its scope ends.
 Static Local variables are used when it is necessary
for a function to remember a value between call to
other functions.
 For example, variable count used in a func
Static Local Variables
 Scope
 Static variable is visible only inside the function in which
it is defined.
 It has the same scope as local variables.

 Life time
 Lifeof a static variable is the same as that of a global
variable, i.e. it remains in existence for the life of the
program.
Example – Static Variables
void function(void);

int main()
{
cout << "Count the number of times the function is
called : ";
for (int i=0; i<5; i++)
function();
}

void function( void )

{
static int count = 1; // initialized first time only
cout << "\nlocal static count is " << count << " on
entering the function" << endl;
count++;
cout << "local static count is " << count << " on
exiting useStaticLocal" << endl;
}
 Variables and Storage Classes

Variable Type Scope Lifetime

Local or Auto Within braces{} Within braces{}
Global or External Entire program Entire program
Static Within braces {} Entire program
Important Points about Functions
 It should be noticed that the prototype is written before the
main () function. This cause the prototype to be visible to all the
functions in a file.
 The presence of ; should be noted carefully .
 The arguments and return type must match to the
corresponding variable types of the prototype and definition.
 Note that you can only return one value from a function,
however you can pass several values to a function.
 If we want to return more than one value from a function then
we have to use pointers.
 We can pass constants as well as variable to the functions.
Important Points about Functions
 We can have same as well as different names for the
variable used in calling and called programs.
 Any function can call any other function.
 All functions are visible to all other functions.
Important Points about Functions
 The variables which are declared inside a function are
only visible to that function and are called local
variables.
 If variable is declared outside the main, it will be visible
to all functions.
 Global variable, use memory less efficiently than local
variables. The rule is that variable, should be local unless
there is a very good reason to make it global.
 A Static variable, declared within the function is visible to
that function only. However it keeps its value b/w call to
the function.