Polymorphism, Virtual Functions and Abstract Class in C++.

Polymorphism, Virtual Functions and Abstract Class

  • The term "Polymorphism" is the combination of "poly" + "morphs" which means many forms. 
  • It is a Greek word. In object-oriented programming, we use 3 main concepts: inheritance, encapsulation, and polymorphism.




  • Compile time polymorphism: The overloaded functions are invoked by matching the type and number of arguments. 
  • This information is available at the compile time and, therefore, compiler selects the appropriate function at the compile time. 
  • It is achieved by function overloading and operator overloading which is also known as static binding or early binding. 
  • Now, let's consider the case where function name and prototype is same.
  • Run time polymorphism: Run time polymorphism is achieved when the object's method is invoked at the run time instead of compile time. 
  • It is achieved by method overriding which is also known as dynamic binding or late binding.
  • Inheritance is a mechanism in which one object naturally acquires all of its parent object's properties and behaviors.
  • In C++, a pointer variable of a base class type can point to an object of its derived class. 
  • There are situations when this feature of C++ can be used to develop generic code for a variety of applications.

Pointer of base class

Consider the following program to understand pointer compatibility property

#include <iostream.h>
#include <conio.h>
class Shape
{
  protected:
    double width, height;
  public:
    void set_data (double a, double b)
    {
        width = a;
        height = b;
    }
};
class Rectangle: public Shape
{
  public:
    double area ()
    {
        return (width * height);
    }
};
int main ()
{
    Shape *sPtr;    //declare pointer variables of type Shape
    Rectangle Rect; //create the object rect of type Rectangle
    sPtr = &Rect;   //make sPtr point to the object rect.
    sPtr->set_data (5,3); //set length and width of object rect 
    cout << sPtr -> area() << endl;  //Compile Error !!
    return 0;
}

  • Notice that even though rectPtr is poining to rect (object of type Rectangle), when the program executes, the statement sets length and width of rectangle. 
  • If you tried to access area function of class Rectangle with sPtr it will give you compiler error.
sPtr -> area()
is a compiler error !

  • It means base class pointer can not access the additional member function of its derived class
  • If we want to do this we need to type cast the base class pointer.

Using Type Casts with Base Class Pointers

  • We can use a type cast to get the compiler to accept the statement:

static_cast <Rectangle *> (sPtr)->area()



so we should write the statement

cout << static_cast <Rectangle *> (sPtr) -> area() << endl;

  • The type cast informs the compiler that sPtr is actually pointing to a Rectangle object derived from the Shape base class. 
  • In general, a pointer to a base class that actually points to a derived class object must first be appropriately cast before the additional features of the derived class can be used.

Virtual Function
  • A virtual function is a member function of base class that you expect to redefine in derived classes.
  • Virtual function is a member function in the base class that you can redefine in a derived class. It is declared using the virtual keyword.
  • It is used to tell the compiler to perform dynamic linkage or late binding on the function.

//Let's take an example to implement Virtual Function.
#include <iostream.h>

#include <conio.h>

class Weapon
{
    public:
       void loadFeatures()
         { cout << "Loading weapon features.\n"; }
};
class Bomb : public Weapon
{
    public:
       void loadFeatures()
         { cout << "Loading bomb features.\n"; }
};
class Gun : public Weapon
{
    public:
       void loadFeatures()
         { cout << "Loading gun features.\n"; }
};
int main()
{
    Weapon *w = new Weapon;
    Bomb *b = new Bomb;
    Gun *g = new Gun;

    w->loadFeatures();
    b->loadFeatures();
    g->loadFeatures();
    return 0;
}
Expected Output:-

Loading weapon features.
Loading bomb features.
Loading gun features.

//Let's take another example to implement Virtual Function.
#include <iostream.h>

#include <conio.h>
class A
{
   int x=5;
    public:
    void display()
    {
        std::cout << "Value of x is : " << x<<std::endl;
    }
};
class B: public A
{
    int y = 10;
    public:
    void display()
    {
        std::cout << "Value of y is : " <<y<< std::endl;
    }
};
int main()
{
    A *a;
    B b;
    a = &b;
   a->display();
    return 0;
}
Expected Output:-

Value of x is : 5

//Let's take another example to implement Virtual Function.
#include <iostream.h>

#include <conio.h>
class Animal
{
 public:
 void my_features()
 {
 cout << "I am an animal.";
 }
};
class Mammal : public Animal
{
 public:
 void my_features()
 {
 cout << "\nI am a mammal.";
 }
};
class Reptile : public Animal
{
 public:
 void my_features()
 {
 cout << "\nI am a reptile.";
 }
};
int main()
{
 Animal *obj1 = new Animal;
 Mammal *obj2 = new Mammal;
 Reptile *obj3 = new Reptile;
 obj1->my_features();
 obj2->my_features();
 obj3->my_features();

 return 0;
}
Expected Output:-

I am an animal.
I am a mammal.
I am a reptile.

Abstract class and pure virtual function
  • C++ abstract class is a class which is designed to perform the role of the base class having at least one pure virtual function. 
  • A class without a pure virtual function cannot be termed as an abstract base class in C++. 
  • Abstract classes are used as a framework upon which new sub-classes are derived.

Syntax:- 


//declaring abstract base class
class base_class
 {
   virtual return_type func_name() = 0; //pure virtual function
 }

//Illustration of abstract class and pure virtual function in C++.
#include <iostream.h>

#include <conio.h>
class base_class
{
 public:
  virtual void display() = 0;
};
class derived_class : public base_class
{
 public:
 void display()
 {
  cout<<"This is simple illustration of abstract class and pure virtual function";
 }
};
int main()
{
  derived_class obj;
  obj.display();
 return 0;
}

Expected Output:-
This is simple illustration of abstract class and pure virtual function

Post a Comment

Previous Post Next Post