Polymorphism and virtual functions

Polymorphism is one of the important features in object-oriented programming language. Polymorphism is the ability to take more than form.

In Greek, “poly” means many “morphism” means forms. It means one function or operator contains more than one forms.

Polymorphism is of two types:

1. Compile-time polymorphism (Function Overloading & Operator Overloading)

2. Run-time polymorphism (Virtual Function)

Polymorphism supports two types of concepts – overloading and overriding. Overloading is possible through compile-time polymorphism. Overriding is possible through compile-time polymorphism.

When working with inheritance, if both base and derived classes are defined with the same member function with the same signature, then member function overriding may occur. To overcome this, dynamic polymorphism is used. The dynamic polymorphism requires virtual functions.

Virtual function:

A virtual function is a member function that is dynamically bound to function calls. In dynamic binding , C++ determines which function to call at runtime, depending on the type of the object responsible for the call.

Virtual functions are declared by placing the key word virtual before the return type in the base class’s function declaration, such as

public:

virtual returntype fun_name(arguments)

{

----------

statements;

}

This declaration tells the compiler to expect fun_name to be redefined in a derived class. The compiler does not bind calls to the function with the actual function. Instead, it allows the program to bind calls, at runtime, to the version of the function that belongs to the same class as the object responsible for the call.

Demonstrating Virtual Functions

#include<iostream.h>

#include<conio.h>

class Base

{

public:

void print()

{

cout<<"\nprint() in Base class";

}

virtual void show()

{

cout<<"\nshow() in Base class";

}

};

class Derived : public Base

{

public:

void print()

{

cout<<"\nprint() in Derived class";

}

void show()

{

cout<<"\nshow() in Derived class";

}

};

void main()

{

clrscr();

Base *ptr;                                                                                                                            

Base b;                                                                                                                                

ptr=&b;            

ptr->print();                                                            

Derived d;                                                                                                                           

ptr=&d;            

ptr->show();                                                                       

getch();                                                                                                                                

}

Output:

print() in Base class

show() in Derived class

Rules For Virtual Functions:

• The virtual functions should not be static and must be member of a class.
• A virtual function may be declared as friend of another class.
• Constructors can’t be declared as virtual but destructors can be virtual.
• The virtual function must be defined in the public section of the class.
• The prototype of virtual functions in base and derived classes should be exactly the same.
• In case of mismatch the compiler neglects the virtual function mechanism and treats them as overloaded function.
• If a base class contain virtual function and if the same function is not redefined in the derived classes in that case the base class function is invoked.
• The keyword virtual prevents the compiler to perform early binding. Binding is postponed until run time.
• The operator keyword used for operator overloading also supports virtual mechanism.