polymorphism

Polymorphism is one of the crucial features of OOP. It simply means ‘one name, multiple forms’. We have already seen how the concept of polymorphism is implemented using the overloaded functions and operators.

            Mainly they are two types of polymorphism.

Types of Polymorphism in C++:

Compile time polymorphism:

         

          The overloaded member functions are ‘selected’ for invoking by matching arguments, both type and number. This information if known to the compiler at the compile time and, therefore, compiler is able to select the appropriate function for a particular call at the compile time itself. This is called early binding or static binding. Also known as compile time polymorphism, early binding means that an object is bound to its function call at compile time.

Run time polymorphism:

Binding in C++:

           class Base                                                  //base

               {

int b;

public:

void display( )                //base member function

{

}

     };

class  Derived: public Base                      //derived

{

int d;

   public:

void display( )                 //derived member function

{

}

};

           

  How do we use the member function display( ) to display the values of objects of both the classes Base and Derived?. Since the prototype of display( ) is the same in both the places, the function is not overloaded and therefore static binding does not apply. We have seen earlier that, in such situations, we may use the class resolution operator to specify the class while invoking the functions with the derived class objects.

            It would be nice if the appropriate member function could be selected while the program is running. This is known as run time polymorphism. How could it happen?

           C++ supports a mechanism known as virtual function to achieve run time polymorphism.

At run time, when it is known what class objects are under consideration, the appropriate version of the function is invoked. Since the function is invoked with a particular class much later after the compilation, this process is termed as late binding. It is also known as dunamic binding because the selection of the appropriate function is done dynamically at run time.

Dynamic Binding is one of the powerful features of C++. This requires the use of pointers to objects. We shall discuss in detail how the object pointers and virtual functions are used to implement dynamic binding.