Static,Dynamic Binding & Virtual Function in C++
Static binding in C++
- In function overloading or operator overloading there will be more than one function with the same name.
- The functions are invoked by matching arguments.
- The complier selects the appropriate function for particular call at the compilation time itself. This is called early binding or static binding.
Dynamic Binding in C++
- Selecting the appropriate member function while the program is running is known as run time polymorphism.
- This process is known as late binding .It is known as dynamic binding as the selection of the function is done dynamically at run time.
- Dynamic binding requires use of pointer to objects
void fun1(int x)
{
{
void fun1(float x)
{
}
void main()
{
fun1(10);
fun1(1.5);
}
The feature of runtime polymorphism is the ability to refer to objects without regard to their classes using a single pointer.
We can use a pointer to a base class to refer all the derived objects.
When we use the same function name in both base and derived classes a base class pointer executes the base class function only even when is assigned with derived class object address.
Virtual Function in C++
- To invoke the derived class overriding member function b base class pointer when i t is assigned with derived class address the base class member function has to made virtual.
- The keyword virtual has to be preceded the normal declaration.
Rules for virtual functions:
- The virtual function must be members of some class.
- They cannot be static members.
- They accessed by using object pointers.
- A virtual function can be a friend of another class.
- A virtual function in a base class must be defined ,even though it may not be used.
Syntax:
Virtual return-type
function_name([parameters])
{
statements;
}
E.g:
# include<iostream.h>
class animal
{
public:
virtual void walk()
cout<<”\n Inside animal walk”;
}};
class dog:public animal
{
public:
void walk()
{
cout<<”\n Inside dog walk”;
}};
class cat: public animal
{
public:
void walk()
{
cou<<”\n Inside cat walk”;
}};
void play(animal *a)
{
(*a).walk();
}
void main()
{
cat c;
dog d;
play(&c);
play (&d);
}
O/p:
Inside cat walk
Inside dog walk
Eg:
# include<iostream.h>
class SIM
{
public:
void connect( ) {
cout<<”Inside connect”;
}};
class airelsim:public sim
{
Public:
Void connect( )
{
Cout<<”In connected to airtel network”;
}};
class bsnlsim:public sim
{
Public:
Void connect( )
{
Cout<<”In connected to bsnl network”;
}};
Class mobile
{
Public:
Static void insert(Sim *s)
{
(*s).connect( );
}};
void main( )
{
Airtle sim airtel;
bsnl sim bsnl;
Mobile::insert(&airtel);
Mobile::insert(&bsnl);
}
o/p:
Inside connect
Inside connect
Pure virtual function:
- A function declared in base class and has no definition relative to the base class.
- They are redefined in derived classes.
- They are called as do-nothing functions.
Abstract Base class:
- A class containing pure virtual functions is called as Abstract Base class
- They cannot be used to declare any objects.
- It is purely for inheriting purpose only.
- They are used to create a base pointer required to achieve runtime polymorphism.
Syntax:
Virtual return type function – name (parameters)
Abstract class
# include<iostream.h>
# include<conio.h>
class shape
{
protected;
float dim 1,dim 2;
public:
void read_dim( )
{
cout<<”Input two dim”;
cin>>dim1>>dim2;
}
Virtual void final_area( )=o;
};
Class triangle:public shape
{
Public:
void final_area( )
{
float area=0.5*dim1*dim2;
cout<<”In area of triangle is”<<area;
}};
class rectangle:public shape
{
public:
void final_area( )
float area=dim1*dim2;
cout<<”In area of rectangle is”<<area;
}};
Void main( )
{
Triangle t1;
t1.read_dim( );
Rectangle r1;
r1.read_dim( );
t1.final_area( );
r1.final_area( );
}
O/P:
Input two dim 2
3
Input two dim5 4
Area of triangle is 3
Area of triangle is 20
- Abstract class is called as an abstract data type
- A data type which allows to build a similar data type is called as abstract data type.
Hybrid Inheritance:
If there are two on more types of inheritances to design a program it is called as hybrid inheritance.
Ex:
class student{ };
class test:public student
{ };class sports:public student
{ };
Class result:public test,public sports;
This is also called as Multi path inheristance as the class student inherited vice test and also via sports
Class alpha
{
};
Class beta:public alpha
{
}
Virtual Class
You might want to make a class if it is a base class it has been passed to more than one derived class,as might happen with multiple inheritance.
- A base class cant be specified more than once in a derived class:
Eg: class B {….}
Class D:B,B{….};//ILLEGAL
However a base class can be indirectly passed to the derived class more than once:
Eg:
Class X:public B {….}
Class Y:public B {….}
Class Z:public X,public Y{….}
In this case, each object of class Z will have sub objects of class B.
If this causes problems, you can add the key word” virtual “to a base class specifier.
For example:
# include<iostream.h>
Class A
{
Public:
Void fun1( )
{
Cout<<”In Inside function1 of A”;
}};
Class B:public virtual A
{
public:
Void fun2( )
{
Cout<<”In Inside function2 of A”;
}};
Class C:public virtual A
{
public:
Void fun 3( )
{
Cout<<”In Inside function3 of C”;
}};
Class D:public B,public C
{
Public:
Void fun4( )
{
cout<<”In Inside function4 of D”;
}};
Void main( )
{
D obj1;
Obj1.fun1( );
Obj1.fun2( );
Obj1.fun3( );
Obj1.fun4( );
}
o/p:
Inside function 1 of A
Inside function 2 of A
Inside function 3 of C
Inside function 4 of D
MULTIPLE INHERITANCE
If class is derived from more than one base class it is called as multiple inheritance.
Ex: class base1
{ };
class base2
{ };
class derived:public base1,public base2
{ };
Example:
# include<iostream.h>
Class person
{
Protected;
Char name[10];
Public;
Void read_name( )
{
Cout<<”\n Input name”;
Cin>>name;
}};
Class employee
{
Protected;
Int empno;
public;
void read_empno( )
{
Cout<<”\n Input empno”;
cin>>empno;
}};
Classworker:public person,public employee
{
Float wage;
Public;
Void read_wage( )
{
Cout<<” \n Input wage”;
Cin>>wage;
}
Void print_details( )
{
Cout<<”In Name”<<name;
Cout<<”In Empno”<<empno;
Cout<<”In Wage”<<wage;
}};
Void main( )
{
Worker worker1;
Worker1.read_name( );
Worker1.read_empno( );
Worker1.read_wage( );
Worker1.print_details( );
}