A function is a self contained block of code written once for a particular purpose but can be used again and again.
Example of a basic function:
#include<iostream>
using namespace std;
void show()
{
cout << " Hello " ;
}
int main()
{
show();
}
Recursion:
Recursion is a programming technique in which a function calls itself for a number of times until a particular condition is satisfied.
Below is a code to find the factorial of a number using recursion:
#include < iostream >
using namespace std;
int fact ( int n )
{
if ( n>1 )
return n * ( fact ( n - 1 ) );
else
return 1;
}
int main()
{
int f = fact ( 5 );
cout << " Fact = " << f;
}
Output:
Fact = 120
Example of call by reference:
Swapping two numbers using call by reference:
#include < iostream >
using namespace std;
void swap (int *n1 , int *n2 )
{
int temp;
temp = *n1;
*n1 = *n2;
*n2 = temp;
}
int main()
{
int a=2 , b=4;
cout << " Before a = " << a << " , b = " << b << endl;
swap ( &a , &b );
cout << "After a = " << a << " , b = " <<b;
}
Output:
Before a=2 , b=4
After a=4 , b=2
Function Overloading:
Overloading refers to use of same thing for different purpose.
Function overloading refers to creating numbers of functions with the same name which performs different tasks.
Function overloading is also known as function polymorphism.
Function overloading relieves us from remembering so many functions names with type of arguments they take.
In function overloading we can create number of functions with the same name but either number of arguments or type of arguments must be different.
Example:
#include<iostream>
using namespace std;
void area ( int l , int b )
{
cout << l * b << endl;
}
void area ( int r )
{
cout << 3.14 * r * r;
}
int main()
{
area (10 , 20);
area ( 5 ) ;
}
Output:
200
78.95
Friend Function:
We can make a function as a friend of a class and can allow that friend function to access private and public data members of that class.
A friend function is created by placing the keyword friend in the function declaration but not in function definition.
A friend function can have full access to the public, private and protected data member of the class to which it is a friend.
Example:
#include < iostream >
using namespace std;
// Finding square of a number
class demo
{
int fx;
public:
void getx ( int x )
{
fx=x;
}
friend int sqr ( demo );
};
int sqr ( demo d )
{
return d.fx * d.fx;
}
int main()
{
demo f;
f.getx ( 5 );
int s = sqr ( f );
cout<< s;
}
Virtual Function:
A virtual function is a member function which is declared within a base class and is re-defined (overridden) by a derived class
Virtual functions ensure that the correct function is called for an object.
They are mainly used to achieve Runtime polymorphism.
Functions are declared with a virtual keyword in base class.
Virtual functions should be accessed using pointer or reference of base class type to achieve runtime polymorphism.
They are always defined in the base class and overridden in a derived class. It is not mandatory for the derived class to override (or re-define the virtual function), in that case, the base class version of the function is used.
#include<iostream>
using namespace std;
class base
{
public:
virtual void display()
{
cout << " Base class ";
}
};
class derived : public base
{
public:
void display()
{
cout << " Derived class";
}
};
int main()
{
base *bptr;
derived d;
bptr = &d;
bptr -> display();
}
Pure virtual function:
A pure virtual function is a virtual function that has no definition within the class.
It can be considered as an empty function means that the pure virtual function does not have any definition relative to the base class.
Programmers need to redefine the pure virtual function in the derived class as it has no definition in the base class.
It means that the class is containing any pure virtual function then we cannot create the object of that class. This type of class is known as an abstract class.
#include<iostream>
using namespace std;
class base
{
public:
virtual void display() {}
};
class derived : public base
{
public:
void display()
{
cout << " Derived class ";
}
};
int main()
{
base *bptr;
derived d;
bptr = &d;
bptr -> display();
}
0 Comments