Functions

What is function????

• Function is a self contained block of statements

that perform a coherent task of some kind.
• Every C++ program can be a thought of the
collection of functions.
• main( ) is also a function.
 Types of Functions.

• Library functions
– These are the in- -built functions of ‘C++ ’library.
– These are already defined in header files.
– e.g. Cout<<; is a function which is used to print at output.
It is defined in ‘iostream.h ’ file .
• User defined functions.
– Programmer can create their own function in C++ to
perform specific task
a) Actual arguments:-the arguments of calling
function are actual arguments.
b) Formal arguments:-arguments of called function
are formal arguments.
c) Argument list:-means variable name enclosed
within the paranthesis.they must be separated by
comma
d) Return value:-it is the outcome of the function.
the result obtained by the function is sent back to
the calling function through the return statement.
Why use function?
• Writing functions avoids rewriting of the same code
again and again in the program.
• Using function large programs can be reduced to
smaller ones. It is easy to debug and find out the
errors in it.
• Using a function it becomes easier to write program
to keep track of what they are doing.
Function Declaration
ret_type func_name(data_type par1,data_type par2);

Function Defination
ret_type func_name(data_type par1,data_type
par2)
{
}

Function Call
func_name(data_type par1,data_type par2);
 Function prototype

• A prototype statement helps the compiler to check

the return type and arguments type of the function.
• A prototype function consist of the functions return
type, name and argument list.
• Example
– int sum( int x, int y);
 Example
#include<iostream.h>
#include<conio.h>
void main()
{
clrscr();
void sum(int, int); // function declaration
int a, b, c;
cout<<“enter the two no”;
cin>>a>>b>>c;
sum(a,b); // function calling
getch();
}
void sum( int x, int y)// function definition
{
c=x+y;
cout<< “ sum is”<<c;
}
#include<conio.h>
void main()
{
clrscr();
int a=10,b=20;
int sum(int, int);
int c=sum(a,b); /*actual arguments
Cout<<“sum is” << c;
getch();
}
int sum(int x, int y) /*formal arguments
{
int s;
s=x+y;
return(s); /*return value
}
 Categories of functions

• A function with no parameter and no return value

• A function with parameter and no return value
• A function with parameter and return value
• A function without parameter and return value
 A function with no parameter and no return value
#include<conio.h>
void main()
{
clrscr();
void print(); /*func declaration
Cout<<“no parameter and no return value”;
print(); /*func calling
getch();
}
void print() /*func defination
{
For(int i=1;i<=30;i++)
{
cout<<“*”;
}
Cout<<“\n”;
}
 A function with no parameter and no return value

• There is no data transfer between calling and called

function
• The function is only executed and nothing is
obtained
• Such functions may be used to print some
messages, draw stars etc
 A function with parameter and no return value

#include<conio.h>
void main()
{
clrscr();
int a=10,b=20;
void mul(int,int);
mul(a,b); /*actual arguments
getch();
}
void mul(int x, int y) /*formal arguments
{
int s;
s=x*y;
Cout<<“mul is” << s;
}
 A function with parameter and return value

#include<conio.h>
void main()
{
clrscr();
int a=10,b=20,c;
int max(int,int);
c=max(a,b);
Cout<<“greatest no is” <<c;
getch();
}
int max(int x, int y)
{
if(x>y)
return(x);
else
{
return(y);
}
}
 A function without parameter and return value

#include<conio.h>
void main()
{
clrscr();
int a=10,b=20;
int sum();
int c=sum(); /*actual arguments
Cout<<“sum is”<< c;
getch();
}
int sum() /*formal arguments
{
int x=10,y=30;
return(x+y); /*return value
}
 Some important points

• A function declaration,defination,and call must

match in number,type and order of actual and
formal arguments.
• A function can b called from other function but a
function cannot be defined inside another function
• Function defined and function call order can b
different
• The actual arguments in a function can be
variables,constants,or expression where as formal
arguments must be variables
ARGUMENT PASSING
TECHNIQUES
 Argument passing techniques

• Pass By Value
• Pass By Reference
• Pass By Pointer\address
 Call By Value

• It is a default mechanism for argument passing.

• When an argument is passed by value then the
copy of argument is made know as formal
arguments which is stored at separate memory
location
• Any changes made in the formal argument are not
reflected back to actual argument, rather they
remain local to the block which are lost once the
control is returned back to calling program
 Example
void main()
{
int a=10,b=20;
int swap(int,int);
Cout<<“before function calling”<<a<<b;
swap(a,b);
Cout<<“after function calling”<<a<<b;
getch();
Return 0;
void swap(int x,int y)
{
int z;
z=x;
x=y;
y=z;
Cout<<“value is”<<x<<y;
}
Output:
before function calling a=10 b=20
value of x=20 and y= 10
after function calling a=10 b=20
 Call By pointer/address
• In this instead of passing value, address are passed.
• Here formal arguments are pointers to the actual
arguments
• Hence change made in the argument are
permanent.
• The address of arguments is passed by preceding
the address operator(&) with the name of the
variable whose value you want to modify.
• The formal arguments are processed by asterisk (*)
which acts as a pointer variable to store the
addresses of the actual arguments
 Example

Void main()
{
int a=10 ,b=25;
void swap(int *,int *);
Cout<<“before function calling”<<a<<b;
swap(&a,&b);
Cout<<“after function calling”<<a<<b;
getch();
}
void swap(int *x,int *y)
{
int z;
z=*x;
*x=*y;
*y=z;
Cout<<“value is”<<*x<<*y;
}
Output:

before function calling a= 10 b= 25

value of x=25 and y=10
after function calling a=25 b= 10
 Using Reference Variables
with Functions

• To create a second name for a variable in a

program, you can generate an alias, or an
alternate name

• In C++ a variable that acts as an alias for another

variable is called a reference variable, or simply a
reference
 Declaring Reference Variables

• You declare a reference variable by placing a type and an

ampersand in front of a variable name, as in double
&cash; and assigning another variable of the same type to
the reference variable

double someMoney;

double &cash = someMoney;

• A reference variable refers to the same memory address as

does a variable, and a pointer holds the memory address of a
variable
 Pass By Reference
void main()
{
int i=10;
int &j=i; // j is a reference variable of I
cout<<“value”<<i<<“\t”<<j;
j=20;
cout<<“modified value”<<i<<“\t”<<j;
getch();
}
Output:-
Value 10 10
modified value 20 20
 Declaring Reference Variables

• There are two differences between reference variables

and pointers:
– Pointers are more flexible
– Reference variables are easier to use
• You assign a value to a pointer by inserting an ampersand
in front of the name of the variable whose address you
want to store in the pointer
• It shows that when you want to use the value stored in the
pointer, you must use the asterisk to dereference the
pointer, or use the value to which it points, instead of the
address it holds
• Call by valueThis method copies the actual value of
an argument into the formal parameter of the
function. In this case, changes made to the
parameter inside the function have no effect on the
argument.
• . Call by pointerThis method copies the address of
an argument into the formal parameter. Inside the
function, the address is used to access the actual
argument used in the call. This means that changes
made to the parameter affect the argument.
• Call by referenceThis method copies the reference
of an argument into the formal parameter. Inside
the function, the reference is used to access the
actual argument used in the call. This means that
changes made to the parameter affect the
argument.
INLINE FUNCTIONS
 Inline Functions

• Each time you call a function in a C++ program, the

computer must do the following:
– Remember where to return when the function eventually ends

– Provide memory for the function’s variables

– Provide memory for any value returned by the function

– Pass control to the function

– Pass control back to the calling program

• This extra activity constitutes the overhead, or cost

of doing business, involved in calling a function.
• Solution to this is to replace each function call
with the necessary code instead of making
function.
• Inline function is a function which gets expanded
inline at each point in the program where it is
called.
• In other words inline functions are those
functions whose function body is inserted in
place of the function call during the compilation
process.
• Syntax:
inline ret_type func_name(parameter_list)
{
inline int max(int x,int y)
{
return (x>y?x:y);
}
int main()
{
int m=10,n=25;
int a,b;
a=max(6,8);
cout<<“greatest is”<<a;
b=max(m,n);
cout<<“greates of m=“<<m<<“ and n=“<<n <<“is “<<b;
getch();
return 0;
}
• Output :
Greatest of 6 and 8=8
Greatest of m=10 and n=25 is 25
• An inline function is a small function with no calling
overhead
• Overhead is avoided because program control
never transfers to the function
• A copy of the function statements is placed directly
into the compiled calling program
• The inline function appears prior to the main(),
which calls it
• Any inline function must precede any function that
calls it, which eliminates the need for prototyping
in the calling function
• When you compile a program, the code for the
inline function is placed directly within the
main() function

• You should use an inline function only in the

following situations:
– When you want to group statements together so that you can
use a function name

– When the number of statements is small (one or two lines in the

body of the function)

– When the function is called on few occasions

 Disadvantages:

• All functions that uses the inline function must be

recompiled if any changes are made to the inline
function.
• Although inline function reduces the execution
time. It increases the size of the executable file as
multiple copies of the inline functions body are
inserted in the programs. So it is always
recommended to use inline functions for small
frequently used functions.
• The definition of inline function should appear
before the function call.
DEFAULT ARGUMENTS
 DEFAULT ARGUMENTS
• Default arguments is useful in situation where a
arguments has the same value in most function calls.
• When the desired value is different from the default
value,the desired value can be specified explicity in a
function call.
• This changes the default value of the argument to be
overridden for the duration of function call.
If in the function call all the arguments are not
specified then the omitted arguments can take
default value by providing them in the function
declaration.
void volume(int l=10,int w=10,int h=10); //function declatration
int main()
{
volume ();
volume(5);
volume(8,6);
volume(6,4,5);
getch();
return 0;
}
void volume(int l,intw,int h)
{
Cout<<“volume =“<<l*w*h<<endl;
}
Output:
Volume:1000
Volume:500
Volume:480
Volume:120
 Using Default Arguments

• When you don’t provide enough arguments in a function call, you

usually want the compiler to issue a warning message for this error

• Sometimes it is useful to create a function that supplies a default

value for any missing parameters
 Using Default Arguments

• Two rules apply to default parameters:

– If you assign a default value to any variable in a
function prototype’s parameter list, then all
parameters to the right of that variable also must
have default values
– If you omit any argument when you call a function
that has default parameters, then you also must leave
out all arguments to the right of that argument
 Examples of Legal and Illegal
Use of Functions with Default Parameters
RECURSIVE FUNCTIONS
 Recursion
• When function call itself repeatedly ,until some
specified condition is met then this process is
called recursion.
• It is useful for writing repetitive problems
where each action is stated in terms of
previous result.
• The need of recursion arises if logic of the
problem is such that the solution of the
problem depends upon the repetition of
certain set of statements with different input
values an with a condition.
Two basic requirements for recursion :
1. The function must call itself again and again.
2. It must have an exit condition.
int main()
{
int factorial (int);
int x,fact;
cout<<“enter a number=“;
cin>>x;
fact=factorial(x);
cout<<“\n factorial of”<<x<<“=“<<fact;
getch();
return 0;
}
int factorial(int a)
{
int b;
if(a==1)
return (1);
• Output:
Enter a number=3
Factorial0f 3=6
 Stack representation

.
. 3*2*fact(1)
3*fact(2) 3*fact(2)
fact(3) fact(3)
fact(3)

3*2*1
3*2*fact(1)
3*fact(2)

fact(3)
 Fibonacci using recursion
int main()
{
int fib(int);
int n;
cout<<“enter the number of terms=“;
cin>>n;
for(int i=1;i<=n;i++)
cout<<fib(i)<<“ “;
getch();
return o;
}
int fib(int m)
{
if(m==1|| m==2)
 Advantages of recursion
1. It make program code compact which is easier to
write and understand.
2. It is used with the data structures such as
linklist,stack,queues etc.
3. It is useful if a solution to a problem is in repetitive
form.
4. The compact code in a recursion simplifies the
compilation as less number of lines need to be
compiled.
 Disadvantages

1. Consume more storage space as recursion calls

and automatic variables are stored in a stack.
2. It is less efficient in comparison to normal program
in case of speed and execution time
3. Special care need to be taken for stopping
condition in a recursion function
4. If the recursion calls are not checked ,the
computer may run out of memory.
 FUNCTION
OVERLOADING
Polymorphism
• The word polymorphism is derived from Greek
word Poly which means many and morphos which
means forms.
• Polymorphism can be defined as the ability to use
the same name for two or more related but
technically different tasks.
• Eg-woman plays role of daughter,sister,wife,mother
etc.
 Overloading in C++

What is overloading
– Overloading means assigning multiple
meanings to a function name or operator
symbol
– It allows multiple definitions of a function with
the same name, but different signatures.
C++ supports
– Function overloading
– Operator overloading
 Why is Overloading Useful?

 Function overloading allows functions that

conceptually perform the same task on
objects of different types to be given the
same name.

 Operator overloading provides a convenient

notation for manipulating user-defined
objects with conventional operators.
Function Overloading
• Is the process of using the same name for two or
more functions
• Requires each redefinition of a function to use a
different function signature that is:
– different types of parameters,
– or sequence of parameters,
– or number of parameters
• Is used so that a programmer does not have to
remember multiple function names
 Function Overloading

• Two or more functions can have the same name but

different parameters
• Example:
int max(int a, int b) float max(float a, float b)
{ {
if (a>= b) if (a>= b)
return a; return a;
else else
return b; return b;
} }
Overloading Function Call Resolution

 Overloaded function call resolution is done by

compiler during compilation
– The function signature determines which
definition
is used
 a Function signature consists of:
– Parameter types and number of parameters
supplied to a function
 a Function return type is not part of function
signature
and is not used in function call resolution
void sum(int,int);

void sum(double,double);

void sum(char,char);

void main()

int a=10,b=20 ;

double c=7.52,d=8.14;

char e=‘a’ , f=‘b’ ;

sum(a,b); //calls sum(int x,int y)

sum(c,d); //calls sum (double x,double y)

sum(e,f); // calls sum(char x,char y)

void sum(int x,int y)

{
vout<<“\n sum of integers are”<<x+y;
}
void sum(double x,double y)
{
cout<<“\n sum of two floating no are”<<x+y;
}
void sum(char x,char y)
{
• Output:
Sum of integers 30
sum of two floating no are 15.66
sum of characters are 195
Void area(int)

Void area(int,int);

Void area(int,int,int);

Int main()

Int side=10,le=5,br=6,a=4,b=5,c=6;

Area(side);

Area(le,br);

Area(a,b,c);

Getch();

Return 0;

Void area(int x)

{ cout<<“area is”<<x*x;

Void area(int x,int y)

{cout<<“area of rectang;e”=<<x*y;
SCOPE RULES
 Scope

• The scope of a variable is the portion of a

program where the variable has meaning (where
it exists).
• A global variable has global (unlimited) scope.
• A local variable’s scope is restricted to the
function that declares the variable.
• A block variable’s scope is restricted to the block
in which the variable is declared.
 Understanding Scope

• Some variables can be accessed throughout an

entire program, while others can be accessed only
in a limited part of the program

• The scope of a variable defines where it can be

accessed in a program

• To adequately understand scope, you must be able

to distinguish between local and global variables
 Local variables

• Parameters and variables declared inside the

definition of a function are local.
• They only exist inside the function body.
• Once the function returns, the variables no longer
exist!
– That’s fine! We don’t need them anymore!
 Block Variables

• You can also declare variables that exist only within

the body of a compound statement (a block):
{
int foo;
…
…
}
 Global variables

• You can declare variables outside of any function

definition – these variables are global variables.
• Any function can access/change global variables.
• Example: flag that indicates whether debugging
information should be printed.
 Distinguishing Between Local
and Global Variables
• Celebrity names are global because they are
known to people everywhere and always refer to
those same celebrities

• Global variables are those that are known to all

functions in a program

• Some named objects in your life are local

• You might have a local co-worker whose name

takes precedence over, or overrides, a global one
 A note about
Global vs. File scope
• A variable declared outside of a function is available
everywhere, but only the functions that follow it in
the file know about it.

• The book talks about file scope, I’m calling it global

scope.
 Block Scope
int main(void) {
int y;

{
int a = y;
cout << a << endl;
}
cout << a << endl;
}
MANIPULATOR FUNCTIONS
• These are special stream functions that change
certain characteristics of input and output.
• The main advantage of using manipulator functions
is that they facilitate the formatting of input and
output stream.
• To carry out the operations of these manipulator
functions the header file <iomanip.h> must be
included.
 Following are the standard manipulators normally used in
the stream classes:

• endl
• hex,dec,oct
• setbase
• setw
• setfill
• setprecision
 endl

• It is an output manipulator to generate a next line

character.
• cout<<“a”<<endl<<“b”
 Setbase()

• Used to convert the base of one numeric value into

another base
#include<iomanip.h>
Void main()
{
int value;
Cout<<“enter number”<<endl;
Cin>>value;
Cout<<“decimal base “<<setbase(10)<<value;
cout<<“hexadecimal base”<<setbase(16)<<value;
Cout<<“octal base”<<setbase(8)<<value;
• Output:
Enter number 10
Decimal base 10
Hexadecimal base=a
Octal base 12
 Setw()

• It is used to specify the minimum number of

character position on the output field a variable will
consume.
void main()
{
int a=200,b=300;
cout<<setw(5)<<a<<setw(5)<<b<<endl;
cout<<setw(6)<<a<<setw(6)<<b<<endl;
cout<<setw(7)<<a<<setw(7)<<b<<endl;
• Output:
200 300
200 300
200 300
200 300
 Setfill()

• It is used to specify a different character to fill the

unused field width of the value.
void main()
int a=200,b=300;
cout<<“setfill(‘*’);
cout<<setw(5)<<a<<setw(5)<<b<<endl;
cout<<setw(6)<<a<<setw(6)<<b<<endl;
}
Output:
 Setprecision()
It is used to control the number of digits of an
output stream display of a floating point value.
The default precision is 6
void main()
{
float a=5,b=3,c=a/b;
cout<<setprecision(1)<<c<<endl;
cout<<setprecision(2)<<c<<endl;
cout<<setprecision(3)<<c<<endl;
}
Output:
1.7
1.67
1.667