Static, Dynamic Binding and 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( ); }