What is Polymorphism?

Polymorphism means to have one interface for different methods or functions.
It is the ability through which we can do different operations (by calling different
functions) from the same interface.

In C++ functions and operators can be made to be polymorphic, but in this article
we’ll only be discussing about polymorphic functions.

There can be two types of polymorphism which are discussed below:

Compile-Time Polymorphism: When we have two or more polymorphic function (overloaded
functions) and the call to a particular function is resolved (or known) at the
compile-time, it is called compile-time polymorphism.

The following example program illustrates this. Please read the comments for
further information.

   // program to demonstrate
   // compile-time polymorphism
   #include<iostream.h>

   // -- FUNCTION  PROTOTYPES --
   // -- OVERLOADED FUNCTIONS --
   void func(int);
   void func(char *);
   // --       ENDS           --

   void main()
   {
     // by seeing the argument
     // passed, anyone can tell
     // which version of the
     // function is being called
     // hence call to particular 
     // polymorphic functions is
     // resolved or known at the
     // time of compilation
     func(10);
     func("Polymorphism");
   }

   void func(int a)
   {
     cout<<a;
     cout<<endl;
   }

   void func(char *str)
   {
     cout<<str;
     cout<<endl;
   }

Run-Time Polymorphism: When the call to a particular function (out of the many
polymorphic functions) is not resolved (or known) until execution then it is
called run-time polymorphism.

The following example program illustrates this. Pay extra attention to the
comments!

   // Program to demonstrate
   // run-time polymorphism
   #include<iostream.h>

   // -- FUNCTION PROTOTYPES --
   void func1();
   void func2();
   // --       ENDS          --

   void main()
   {
     int ch=0;
     // here pointer to function
     // is declared which will
     // be used to call one of 
     // the two functions
     void (*ptr)();

     while(ch!=3)
     {
       cout<<"1> Call Func1";
       cout<<"\n2> Call Func2";
       cout<<"\n3> Quit\n";

       cin>>ch;

       switch(ch)
       {
        case 1:
         // make 'ptr' point
         // to func1
         ptr=func1;
         break;

        case 2:
         // make 'ptr' point
         // to func2
         ptr=func2;
         break;
       }

       // call whichever
       // function is selected
       // PLEASE NOTE THAT IT IS
       // NOT POSSIBLE TO TELL
       // WHICH OF THE TWO 
       // FUNCTION WILL BE 
       // CALLED. HENCE CALL
       // TO A PARTICULAR
       // PLOYMORPHIC FUNCTION
       // REMAINS UNRESOLVED
       (*ptr)();
     }
   }

   // -- FUNCTIONS DEFINITION --
   void func1()
   {
     cout<<"Called Func1!\n";
   }

   void func2()
   {
     cout<<"Called Func2!\n";
   }
   // --         ENDS         --

Good-Bye!

Related Articles:

• 
  Pointers to Function