polymorphism

Back to: 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. A real-life example of polymorphism is how a person at can have different characteristics at the same time. Someone can be a father, a husband and an employee! So the same person possesses different behaviours, in different situations. This is called polymorphism. Polymorphism is considered to be an important feature of Object Oriented Programming.

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

• Compile-time Polymorphism
• Runtime Polymorphism

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 change in number of arguments or/and change in 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 is the property of polymorphism.
• Operator overloading: C++ also provide options 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.

// 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.

// 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