C++ LANGUAGE POLYMORPHISM

COMPUTER LANGUAGES HTML,C,C++.JAVA,.NET AND MULTIMEDIA basics and programs click home button

C++ LANGUAGE POLYMORPHISM

POLYMORPHISM 

The word polymorphism means having many forms. Typically, 
polymorphism occurs when there is a hierarchy of classes 
and they are related by inheritance. 

C++ polymorphism means that a call to a member 
function will cause a different function to be 
executed depending on the type of object that invokes the function. 

Consider the following example where a base 
class has been derived by other two classes: 

#include <iostream>  
using namespace std; 
  
class Shape { 
   protected: 
      int width, height; 
   public: 
      Shape( int a=0, int b=0) 
      { 
         width = a; 
         height = b; 
      } 
      int area() 
      { 
         cout << "Parent class area :" <<endl; 
         return 0; 
      } 
}; 
class Rectangle: public Shape{ 
   public: 
      Rectangle( int a=0, int b=0):Shape(a, b) { } 
      int area () 
      {  
         cout << "Rectangle class area :" <<endl; 
26. POLYMORPHISM 
         return (width * height);  
      } 
}; 
class Triangle: public Shape{ 
   public: 
      Triangle( int a=0, int b=0):Shape(a, b) { } 
      int area () 
      {  
         cout << "Triangle class area :" <<endl; 
         return (width * height / 2);  
      } 
}; 
// Main function for the program 
int main( ) 
{ 
   Shape *shape; 
   Rectangle rec(10,7); 
   Triangle  tri(10,5); 
 
   // store the address of Rectangle 
   shape = &rec; 
   // call rectangle area. 
   shape->area(); 
 
   // store the address of Triangle 
   shape = &tri; 
   // call triangle area. 
   shape->area(); 
    
   return 0; 
} 
 
 
When the above code is compiled and executed, 
it produces the following result: 

Parent class area 
Parent class area 

The reason for the incorrect output is that the call of 
the function area() is being set once by the compiler as 
the version defined in the base class. This is called 
static resolution of the function call, or static 
linkage - the function call is fixed before the program 
is executed. This is also sometimes called early binding 
because the area() function is set during the compilation 
of the program. 

But now, let's make a slight modification in our program 
and precede the declaration of area() in the Shape class 
with the keyword virtual so that it looks like this: 

class Shape { 
   protected: 
      int width, height; 
   public: 
      Shape( int a=0, int b=0) 
      { 
         width = a; 
         height = b; 
      } 
      virtual int area() 
      { 
         cout << "Parent class area :" <<endl; 
         return 0; 
      } 
}; 
After this slight modification, when the previous example 
code is compiled and executed, it produces the following result: 

Rectangle class area 
Triangle class area 

This time, the compiler looks at the contents of the 
pointer instead of its type. Hence, since addresses 
of objects of tri and rec classes are stored in *shape 
the respective area() function is called. 

As you can see, each of the child classes has a separate 
implementation for the function area(). This is how 
polymorphism is generally used. You have different 
classes with a function of the same name, and even the 
same parameters, but with different implementations.