concept of functions and its types in c++ language

C++ PRESENTATION
FUNCTIONS
P.P.Krishnaraj
RSET

FUNCTIONS
Void main()
{
Statement 1;
Statement 2;
Statement 3;
.
.
.
.
Statement n;
}
Void main()
{
Statement 1;
Statement 2;
Sum1();
Statement 3;
Statement 4;
Sum2();
Statement 5;
Statement 6;
}
P.P.Krishnaraj RSET

Advantages
• Support for modular programming
• Reduction in program size.
• Code duplication is avoided.
• Code reusability is provided.
• Functions can be called repetitively.
• A set of functions can be used to form libraries.
P.P.Krishnaraj RSET

Types
1.Built in functions :-
are part of compiler package.
Part of standard library made available by compiler.
Can be used in any program by including respective header file.
2. User defined functions:-
Created by user or programmer.
Created as per requirement of the program.
P.P.Krishnaraj RSET

User defined function
Void main()
{
Statement 1;
Statement 2;
multiply();
Statement3;
-------------;
-------------;
Sum();
return0;
}
multiply()
{
-----;
} P.P.Krishnaraj RSET

Parts of a function
main function
{
function prototype declaration
function call
-------;
}
function declaratory/definition
{
------;
return statement
}
P.P.Krishnaraj RSET

Function prototype
A function prototype is a declaration of a function that tells the program about
the type of value returned by the function, name of function, number and type
of arguments.
4 parts
i. Return type
ii. Function name
iii. Argument list
iv. Terminating semicolon
Variable declaration
Data_type variable_name ;
int x=5;
float marks;
int price;
Syntax: Return_type function_name (parameter list/argument);
int add(int,int);
void add(void);
int add(float,int);
P.P.Krishnaraj RSET

Function call
A function must be called by its name followed by argument list enclosed
in semicolon.
Suppose int add(int,int); //prototype
Now to this function add(x,y); //function call
or
add(40,60);
Syntax: function_name (parameter list/argument);
add(x,y);
add(40,60);
add(void); or add();
Note: data type not to be mentioned.
P.P.Krishnaraj RSET

Suppose int add(int,float); //prototype
add(x,y); //function call
int float
Now suppose the function return some integer value, you can use a
variable to store that value.
i.e z=add(x,y);
P.P.Krishnaraj RSET

Parts of a function
main function
{
function call
}
{
return statement
}
P.P.Krishnaraj RSET

Function definition
Syntax: function_type function_name(parameter list)
{
Local variable declaration;
Function body statement;
Return statement;
}
Function
header
Function
body
2 parts
Note: no semicolon in header
Example: int add(int,int); //prototype
Z=add(x,y); //function call
int add(int a,int b) //function definition
{
body statement;
Return(a+b);
}
P.P.Krishnaraj RSET

#include<iostream.h>
using namespace std;
int main()
{
return 0;
}
void print()
{
cout<<“2 is even no.”<<endl;
}
Print();
Error message since
print was not declared in
the scope.
int main()
{
Print();
return 0;
}
void print()
{
}
P.P.Krishnaraj RSET

Why prototyping?????
int main()
{
print();
return 0;
}
void print()
{
}
void print();
function_name(parameter list/argument);
Return_type function_name (parameter list/argument);
function_type function_name(parameter list)
P.P.Krishnaraj RSET

Parts of a function
main function
{
function call
-------;
}
{
------;
return statement
}
Return_type function_name(arguments); eg: int add(int);
function_name(actual arguments); eg: add(a);
Return_type function_name(formal arguments) eg: int add(int X);
P.P.Krishnaraj RSET

Function categories
i) Function with no return value and no argument.
void add(void);
ii) Function with arguments passed and no return value.
void add(int,int);
iii) Function with no arguments but returns a value.
int add(void);
iv) Function with arguments and returns a value.
int add(int,int);
P.P.Krishnaraj RSET

I. Function with no return value and no argument
void main()
{
void disp(void); //prototype
disp(); //caller function
return 0;
}
void disp() //calle function
{
cout<<“--------”<<endl;
}
No arguments passed
from caller to calle
No value returned from
calle to caller function
P.P.Krishnaraj RSET

//program to print square of a number using functions.
void main()
{
void sqr(void);
sqr();
getch();
return 0;
}
void sqr()
{
int no;
cout<<“enter a no.”;
cin>>no;
cout<<“square of”<<no<<“is”<<no*no;
}
P.P.Krishnaraj RSET

ii. Function will not return any value but passes argument
#include<conio.h>
void add(int,int);
int main()
{
int a,b;
cout<<“enter values of a and b”<<endl;
cin>>a>>b;
add(a,b);
getch();
return 0;
}
void add(int x,int y)
{
int c;
c=x+y;
cout<<“addition is”<<c;
}
add(a,b);
a b
void add(int x,int y);
P.P.Krishnaraj RSET

iii) Function with arguments and return value
main function
{
int sqr(int); //function prototype
int a,ans;
cout<<“enter a number”;
cin>>a;
ans=sqr(a); //function call
cout<<“square of number is”<<ans;
getch();
return 0;
}
int sqr(int X) //function declaratory/definition
{
return(X*X);
}
P.P.Krishnaraj RSET

iv) Function with no arguments but returns a value
int main()
{
int add(void);
int z;
z=add();
cout<<sum of 2 nos is”<<z;
getch();
return 0;
}
int add(void);
{
int a,b;
cout<<“enter 2 nos”;
cin>>a>>b;
return(a+b);
}
Function call
add(x,y);
i.e z=add(x,y);
P.P.Krishnaraj RSET

Pointers
• Special type of variables which hold the address of another variable
i.e no values or datas are stored but it points to another variable
where data is stored.
100
int a=100;
1)a name
 2)value
3)address
Pointer stores
this memory
location, no
direct value is
stored.
P.P.Krishnaraj RSET

Declaration: Data_type *variable_name;
int a=100;
int *ptr;
Intialisation: ptr=&a; //referencing
“Address of” operator
100
address 1
a
address 1
ptr
address 2
or
int a=100;
int *ptr=&a;
Pointer initialisation
and declaration
P.P.Krishnaraj RSET

Note: a pointer can be used to point to another pointer also i.e it can
store the address of another pointer.
int a=100;
int *ptr=&a;
int **ptr1=&ptr;
100
address 1
a
address 1
ptr
address 2
address 2
ptr1
address 3
Note: pointer 1 points to address of ptr.
cout<<a; //100
cout<<*ptr;//100
cout<< **ptr1; //100
P.P.Krishnaraj RSET

#include<iosream.h>
#include<conio.h>
int main()
{
int a=100;
int *p1;
int * *p2;
p1=&a; //p1 points to address of a
p2=&p1; // p2 points to address of p1
cout<<“address of a”<<&a;
cout<<“address of a”<<p1;
cout<<“value of a”<< *p1;
cout<<“value of a”<< * *p2;
cout<<p2;
cout<< *p2;
getch();
}
100
address 1
a
address 2
p2
address 3
address 1
p1
address 2
Chain of pointers
P.P.Krishnaraj RSET

Reference variable in C++
When a variable is declared as reference, it becomes an alternative name
for an existing variable. A variable can be declared as reference by
putting ‘&’ in the declaration.
int a=100;
Now we will use a reference variable i.e two names
for same memory location.
int a=100;
int &ref=a; //initialization and declaration
Now in program we can use either “a” or an
alternative name “ref”
C=a+b; //same output
C=ref+b;
100
a
0012dcD2
P.P.Krishnaraj RSET

Program using reference variable
#include<conio.h>
int main()
{
int a=100;
int &ref=a;
cout<<“value of a is”<<a;
cout<<“value of ref is”<<ref;
cout<<address of a is”<<&a;
cout<<address of a is”<<&ref;
getch();
}
100
100
0012dcD2
0012dcD2
Both “a” and “ref” are used for
same memory location as
alternative name
P.P.Krishnaraj RSET

Call by value
A function can be invoked in two manners
(i)call by value
(ii)call by reference
The call by value method copies the value of actual parameters into formal
parameters i.e the function creates its own copy of arguments and uses
them.
add(a,b);
}
void add(int x,int y);
{
--------;
}
Values of variables a
and b are passed to
X,Y
Now if you change
the value of X and Y,
those changes are
not seen in a and b
Call by value
where the values of
variable are passed
to functions
P.P.Krishnaraj RSET

/* program to illustrate the concept of call by value */
#include<conio.h>
void add(int,int);
int main()
{
int a,b;
cout<<“enter values of a and b”<<endl;
cin>>a>>b;
add(a,b);
getch();
return 0;
}
void add(int x,int y)
{
int c;
c=x+y;
cout<<“addition is”<<c; P.P.Krishnaraj RSET

Call by reference
In call by reference method in place of calling a value to the function being
called , a reference to the original variable is passed .i.e the same variable value
can be accessed by any of the two names.
add(a,b);
}
void add(int &x,int &y);
{
--------;
}
In function call
We write reference
variable for formal
arguments
&X,&Y will be the
reference variable for
a and b. if we change
X and Y, Value of a
and b are changed
accordingly
No need for return
statement
P.P.Krishnaraj RSET

Program to illustrate call by reference
#include<conio.h>
void swap(int &,int &);
int main()
{
int a,b;
cout<<“enter the values of a and b”;
cin>>a>>b;
cout<<“before swaping”;
cout<<“A”<<a;
cout<<“B”<<b;
swap(a,b);
cout<<“after swaping”;
cout<<“A”<<a;
cout<<“B”<<b;
getch();
}
void swap(int &X,&Y)
{
int temp;
temp=X;
X=Y;
Y=X;
}
P.P.Krishnaraj RSET

concept of functions and its types in c++ language

Recommended

More Related Content

Similar to concept of functions and its types in c++ language (20)

More from soniasharmafdp (15)

Recently uploaded (20)

concept of functions and its types in c++ language