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 and area() method has been implemented by the two sub-classes with different implementation.
#include<iostream>
usingnamespacestd;
classShape{
protected:
int width, height;
public:
Shape(int a=0,int b=0)
{
width= a;
height= b;
}
int area()
{
cout<<“Parent class area :”<<endl;
return0;
}
};
classRectangle:publicShape{
public:
Rectangle(int a=0,int b=0)
{
Shape(a, b);
}
int area ()
{
cout<<“Rectangle class area :”<<endl;
return(width * height);
}
};
classTriangle:publicShape{
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;
Rectanglerec(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();
return0;
}
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:
classShape{
protected:
int width, height;
public:
Shape(int a=0,int b=0)
{
width= a;
height= b;
}
virtualint area()
{
cout<<“Parent class area :”<<endl;
return0;
}
};
After this slight modification, when the previous example code is compiled and executed, it produces the following result:
Rectangleclass area
Triangleclass area
