C++ Polymorphism

Polymorphism refers to the fact that something exists in several forms. Polymorphism, in simple terms, is the ability of a message to be presented in several formats. A real-life example of polymorphism is when two people have distinct qualities at the same time. At the same time, he is a parent, a spouse, and a worker. As a result, the same individual behaves differently in different settings. Polymorphism is the term for this. One of the most significant characteristics of Object Oriented Programming is polymorphism.

Polymorphism in C++ is primarily classified into two types:

• Polymorphism in compile time
• Polymorphism at Runtime

Polymorphism at compile time

 This sort of polymorphism is done by function or operator overloading.

• Function Overloading: When there are numerous functions with the same name but distinct arguments, this is referred to as overloading. Changes in the amount of arguments or the kind of arguments can cause functions to become overloaded.
• Overloading Operators:  C++ also allows you to overload operators. For example, we can use the string class's operator ('+') to concatenate two strings. This is the addition operator, and its job is to add two operands. So, when the operator '+' is used between integer and string operands, it adds them together, and when it is used between string operands, it concatenates them.

Polymorphism at Runtime

Function Overriding is used to create this form of polymorphism.

• Function overriding, on the other hand, happens when a derived class defines one of the base class's member functions. It's alleged that the basic function has been overridden.
• Virtual function: The term virtual is used to declare a virtual function. A virtual function's return type can be int, float, or void. A virtual function is a base class member function. In a derived class, we can redefine it. It's a type of polymorphism known as run-time polymorphism. The virtual function must be declared in the base class using the term virtual. A virtual function isn't the same as a static function. The virtual function is used to instruct the compiler whether the function should be dynamically bound or late bound. If it's required to refer to all of the distinct classes' objects using a single pointer. This is due to the fact that we will need to build a reference to the base class that will refer to all of the derived objects.
• Pure Virtual Function: We call such functions "Do-nothing functions" or "Pure virtual functions" when they have no definition. This function's declaration occurs without a definition in the base class.

Polymorphism at compile time	Polymorphism at Runtime
At compilation time, the function to be called is known.	At runtime, the function to be called is known.
Overloading, early binding, and static binding are other terms for the same thing.	Overriding, Dynamic binding, and late binding are other terms for it.
Overloading is a compile-time polymorphism in which many methods with the same name but different numbers or types of arguments are created.	Overriding is a sort of run-time polymorphism in which more than one method has the same name, number of parameters, and parameter type.
Function overloading and operator overloading are used to achieve this.	Virtual functions and pointers are used to accomplish this.
As it is known at build time, it allows quick execution.	It delivers delayed execution due to the fact that it is known at run time.
It is less flexible since almost everything happens at build time.	It's more adaptable since everything happens at the same time.

In C++, a real-time example of polymorphism

When we connect a concept to a real-life example, it becomes evident.

Let's look at a few real-world polymorphism instances in C++.

• At the same time, a person might have many positions and responsibilities. A woman has several hats to wear throughout her life, including mother, wife, daughter, daughter-in-law, sister, and so on.
• A guy acts as an office worker, a son or spouse at home, a mall consumer, and so on.
• A mobile phone is a single device with several functions such as a camera, radio, and so on.

Example of a run-time polymorphism with data members

#include <iostream>    
using namespace std;    
class Animal {                                           
class declaration.  
    public:    
    string color = "White";      
};     
class Rabbit: public Animal                      
Animal class.  
{      
 public:    
    string color = "pink";      
};    
int main(void) {    
     Animal r= Rabbit();      
    cout<<r.color;     
}    

Output

White

Example of run-time polymorphism with two derived classes

#include <iostream>
using namespace std;


class Polygon {
    public:
    virtual void show() {
        cout<<"It is a polygon"<<endl;
    }
};
class Hexagon : public Polygon {
    public:
    void show() {
        cout<<"Hexagon is a 6 sided polygon"<<endl;
    }
};
class Pentagon : public Polygon {
    public:
    void show() {
        cout<<"Pentagon is a 5 sided polygon"<<endl;
    }
};


int main() {
  Polygon *P;
  Hexagon h;
  Pentagon p;
  P = &h;
  P->show();
  P = &p;
  P->show();
  return 0;
}

Output

Hexagon is a 6 sided polygon
Pentagon is a 5 sided polygon