www.sakshieducation.

com

Polymorphism
‘Poly’ means ‘many’ and ‘morph’ means ‘form’ that is Polymorphism means having many forms
in one thing. It is the ability of an object to assume or become many different forms of object. In
general term polymorphism is occurrence of entity that has single name and many forms which
acts differently in different situations. The best real time example is Air Conditioner. It is a

m
single device which performs different actions according to different situations, like in winter it
heats the air and in summer it cools the air. One more example is human being. A human being

co
having different behaviors in different situations like a man behaves differently with his father,
with his wife he has different behavior, and with his friends he has different behavior and so on.

n.
io
In inheritance polymorphism is done by method (function) overriding, when base class and
derived class have member functions with same declaration but different definition.

at
uc
Function Overriding
ed

Function overriding is object oriented programming feature that enables a child class to
provide different implementation for a method that is already defined in its parent class or one of
hi

its parent classes. The overridden method in the child class should have the same name, signature
and arguments as the one in its parent class. If the base class and derived class have member
ks

functions with same name and arguments and if we create an object of derived class and write
code to access that member function then the member function in derived class is only invoked
a
.s

that is the member function of derived class overrides the member function of base class, this
mechanism is known as function overriding.
w
w

Important points to remember:

w

• For function overriding Inheritance must be there. Function overriding cannot be done
within a class, for this we need a derived class and a base class.
• When a function of base class redefined in the derived class is called overriding.
• Function that is redefined must have exactly the same declaration in base class and derived
class with same name, same arguments and same return type.

www.sakshieducation.com
 www.sakshieducation.com

• Functions should have same data type.

• Overriding is the concept of runtime polymorphism.
• Functions should be defined in public section.

Example for Function overridden:

m
The following example programs show the function overridden mechanism.

co
n.
io
at
uc
ed
hi
a ks
.s
w
w
w

Figure1: Function overriding mechanism

Accessing overridden function in base class from derived class using scope resolution operator:

www.sakshieducation.com
 www.sakshieducation.com

We can access the overridden function in base class from derived class using ‘::’ scope
resolution operator.

m
co
n.
io
at
uc
ed
hi
a ks
.s
w
w
w

Figure2: Accessing overridden function in base class using scope resolution operator

Let us consider an example which will show the function overridden mechanism and
accessing overridden function in base class from derived class using scope resolution operator.

#include <iostream>

www.sakshieducation.com
 www.sakshieducation.com

#include <string>

using namespace std;

class A
{
private:
int roll_no;
string name;

public:

m
void print()
{

co
cout << "Base Class" << endl;
}

n.
void get_info(int x, string y)
{
roll_no = x;

io
cout << roll_no << endl;
name = y;
cout << name << endl;

at
}
};
uc
class B : public A
{
ed

private:
int roll_no;
string name;
hi

public:
ks

void get_info(int x, string y)

{
roll_no = x;
a

cout << roll_no << endl;

name = y;
.s

cout << name << endl;

}
w

void print()
{
w

cout << "Derived Class" << endl;

cout << "==================================================" << endl;
A::get_info(2222, "Accessing_overriden_fun_from_Derived_class!!!");
w

A::print();
}

};

int main()
{
B obj;
obj.get_info(1111, "Invoking_deriverd_class_function....");

www.sakshieducation.com
 www.sakshieducation.com

obj.print();
system("pause");
return 0;
}

m
co
n.
Figure3: Output of the program

io
at
Virtual Function uc
A Virtual function is a member function that is declared within the base class and
redefined by the derived class. The virtual function is overridden in the derived class, which tells
ed

the compiler to perform late binding on this function. ‘Virtual’ is a keyword is used to declare
virtual function in the base class. When a class contains a virtual function which is inherited,
hi

then the derived class redefines the virtual function to perform their own actions.
ks

Example program without using virtual keyword:

a
.s

#include <iostream>
w

using namespace std;

class Base //Base class

w

{
public:
w

void display()
{
cout << "Base class" << endl;
}
};

class Derived : public Base // Derived class

{
public:

www.sakshieducation.com
 www.sakshieducation.com

void display()
{
cout << "Derived class" << endl;
}
};

int main()
{
Base *ptr; // Base class pointer
Derived obj; // Derived class object
ptr = &obj; // assigning derived class object to base class pointer

m
ptr ‐>display();
system("pause");
return 0;

co
}

n.
io
at
uc
Figure4: Output of the program
ed

When Base class pointer points to derived class object and using base class pointer if we call
hi

functions which are in both classes, then the base class function is invoked. But if we want call
ks

only derived class function using base class pointer, it can be done by using virtual keyword by
defining the functions as virtual functions in the base class. In this way the virtual functions
a

support runtime polymorphism.

.s

Example program using virtual keyword:

w

In the same example we are changing the ‘display ()’ function in the base class as virtual
w

function by using ‘virtual’ keyword. Here virtual keyword will lead to late binding of that
w

function as shown in below.

Virtual void display ()

{

www.sakshieducation.com
 www.sakshieducation.com

#include <iostream>

using namespace std;

class Base //Base class

{
public:
virtual void display()
{
cout << "Base class" << endl;
}

m
};

class Derived : public Base // Derived class

co
{
public:
void display()

n.
{
cout << "Derived class" << endl;
}

io
};

int main()

at
{
Base *ptr; // Base class pointer
Derived obj;
uc
// Derived class object
ptr = &obj; // assigning derived class object to base class pointer
ptr ‐>display();
system("pause");
ed

return 0;
}
hi
a ks

Figure5: Output of the program

.s
w

In the above program using virtual function in the base class, late binding takes place and the
w

derived class function will be called because the base class pointer points to derived class object.
w

So the output here is “Derived class”.

www.sakshieducation.com
 www.sakshieducation.com

Pure Virtual Function

Pure virtual function is a virtual function which has only declaration part and don’t have
any definition. It start with ‘virtual’ keyword and ends with ‘=0’.

Syntax:

m
virtual void function () = 0;

co
Example:

n.
class Base
{

io
public:

at
virtual void display () = 0; // pure virtual function
};
uc
ed

The ‘=0’ notation indicates that the virtual function is pure virtual function and it has no
definition.
hi

Abstract Class
a ks

The Abstract class is a class which contains at least one pure virtual function. These
.s

classes are used to provide an interface for its derived classes. Classes inheriting an abstract class
must provide definition to the pure virtual function otherwise they will also become abstract
w

classes.
w

Characteristics of Abstract class:

w

• Abstract class can have normal variables and functions along with a pure virtual function.
• Abstract class cannot be instantiated, but pointers and references of abstract class can be
created.

www.sakshieducation.com
 www.sakshieducation.com

• Classes inheriting an abstract class must implement all pure virtual functions otherwise
they will become abstract classes.
• Abstract classes mainly used for up casting, so that it’s derived classes can use its
interface.

Example for Abstract class and pure virtual function

m
co
n.
io
at
uc
ed
hi
a ks
.s
w
w
w

Figure6: Output of the program

In the above example the base class is abstract class, so we cannot create object of base class.

www.sakshieducation.com
 www.sakshieducation.com

Virtual Destructors

The destructors in base class can be Virtual but not the constructors. Whenever up casting
is done, the destructors of the base class must be made virtual for proper destruction of the object
when the program exits.

Let us consider an example with destructor and without destructor and observe the changes.

m
Example without Virtual destructor

co
n.
io
at
uc
ed
hi
a ks
.s
w
w
w

Figure7: Output of the program

www.sakshieducation.com
 www.sakshieducation.com

In the above example the ‘delete b’ will only call the base class destructor, which is undesirable
because the object of Derived class is un-destructed, its destructor is never called and which
results memory leak.

Example with Virtual destructor

m
co
n.
io
at
uc
ed
hi
a ks
.s
w
w
w

Figure8: Output of the program

In the above example we have used virtual destructor inside the class, so first the derived class
destructor is called and then the base class destructor is called as shown in the output figure.

www.sakshieducation.com
 www.sakshieducation.com

Pure Virtual Destructors

The pure virtual destructor will make its base class abstract, so that we cannot create
object of that class. There is no requirement of defining pure virtual destructor in the derived
classes. The only difference between virtual destructor and pure virtual destructor is pure virtual
destructor make its base class abstract hence you cannot create object of that class.

m
Example:

co
class Base

n.
{
public:

io
virtual ~Base() = 0; // pure virtual destructor

at
};
class Derived : public Base
uc
{
public:
ed

~Derived ()
{
hi

cout << “Derived Destructor”;

ks

}
};
a
.s
w
w
w

www.sakshieducation.com