What is Polymorphism? Discuss its types with suitable examples.

Polymorphism in C++

The word polymorphism means having many forms. We can define polymorphism as the ability of a message to be displayed in more than one form.
Real-life examples of polymorphism, a person at the same time can have different characteristics. Like a man at the same time is a father, a husband, an employee. So the same person possesses different behavior in different situations. This is called polymorphism.
Polymorphism is considered as one of the important features of Object-Oriented Programming.

In C++ polymorphism is mainly divided into two types:

·        Compile-time Polymorphism

·        Runtime Polymorphism

1.     Compile-time polymorphism: This type of polymorphism is achieved by function overloading or operator overloading.

·        Function Overloading: When there are multiple functions with the same name but different parameters then these functions are said to be overloaded. Functions can be overloaded by a change in a number of arguments or/and change in the type of arguments.

Rules of Function Overloading

// C++ program for function overloading #include <bits/stdc++.h>    using namespace std; class Geeks {     public:            // function with 1 int parameter     void func(int x)     {         cout << "value of x is " << x << endl;     }            // function with same name but 1 double parameter     void func(double x)     {         cout << "value of x is " << x << endl;     }            // function with same name and 2 int parameters     void func(int x, int y)     {         cout << "value of x and y is " << x << ", " << y << endl;     } };    int main() {            Geeks obj1;            // Which function is called will depend on the parameters passed     // The first 'func' is called      obj1.func(7);            // The second 'func' is called     obj1.func(9.132);            // The third 'func' is called     obj1.func(85,64);     return 0; }

Output:

value of x is 7

value of x is 9.132

value of x and y is 85, 64

In the above example, a single function named func acts differently in three different situations which are the property of polymorphism.

·        Operator Overloading: C++ also provides an option to overload operators. For example, we can make the operator (‘+’) for string class to concatenate two strings. We know that this is the addition operator whose task is to add two operands. So a single operator ‘+’ when placed between integer operands, adds them and when placed between string operands, concatenates them.
Example:

// CPP program to illustrate // Operator Overloading #include<iostream> using namespace std;     class Complex { private:     int real, imag; public:     Complex(int r = 0, int i =0)  {real = r;   imag = i;}             // This is automatically called when '+' is used with     // between two Complex objects     Complex operator + (Complex const &obj) {          Complex res;          res.real = real + obj.real;          res.imag = imag + obj.imag;          return res;     }     void print() { cout << real << " + i" << imag << endl; } };     int main() {     Complex c1(10, 5), c2(2, 4);     Complex c3 = c1 + c2; // An example call to "operator+"     c3.print(); }

Output:

12 + i9

In the above example, the operator ‘+’ is overloaded. The operator ‘+’ is an addition operator and can add two numbers(integers or floating-point) but here the operator is made to perform addition of two imaginary or complex numbers. 

2.    Run time polymorphism: This type of polymorphism is achieved by Function Overriding.

·      Function overriding: on the other hand occurs when a derived class has a definition for one of the member functions of the base class. That base function is said to be overridden.

// C++ program for function overriding    #include <bits/stdc++.h> using namespace std;    class base { public:     virtual void print ()     { cout<< "print base class" <<endl; }         void show ()     { cout<< "show base class" <<endl; } };     class derived: public base { public:     void print () //print () is already virtual function in derived class, we could also declared as virtual void print () explicitly     { cout<< "print derived class" <<endl; }         void show ()     { cout<< "show derived class" <<endl; } };    //main function int main()  {     base *bptr;     derived d;     bptr = &d;             //virtual function, binded at runtime (Runtime polymorphism)     bptr->print();              // Non-virtual function, binded at compile time     bptr->show();         return 0; }

Output:

print derived class

show base class