Polymorphism is one of the four core concepts of Object-Oriented Programming (OOP), along with encapsulation, inheritance, and abstraction. The term polymorphism is derived from two Greek words; poly (many) and morph (forms). In programming, it means one name, many forms. In simple words, polymorphism allows a single function, operator, or object to behave differently based on the context. This makes our code flexible, reusable, and easy to extend.

Understanding Polymorphism

Think about the word “drive”.
A car drives, a bike drives, and a bus drives. The action “drive” is the same, but the behavior is different depending on the object. This is polymorphism; the same operation acting differently for different entities.

Similarly, in a company, the manager, designer, and developer all respond to the command “Work!”, but each performs a different task. This is how polymorphism works in real life and also in programming.

What Is Polymorphism in C++

Polymorphism in C++ is the ability of a function, operator, or object to take many forms. It allows the same function name to perform different tasks depending on the type of object or the number of parameters. Polymorphism provides the foundation for dynamic behavior in software, allowing us to write programs that can adapt at runtime.

Types of Polymorphism in C++

C++ supports two main types of polymorphism:

Compile-Time (Static) Polymorphism

Compile-time polymorphism means the decision about which function to call is made before the program runs. This is achieved using function overloading and operator overloading.

Function Overloading Example

#include <iostream>
using namespace std;

class Math {
public:
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    Math m;
    cout << "Sum of two integers: " << m.add(2, 3) << endl;
    cout << "Sum of two doubles: " << m.add(2.5, 3.8) << endl;
    cout << "Sum of three integers: " << m.add(1, 2, 3) << endl;
    return 0;
}

Operator Overloading Example

#include <iostream>
using namespace std;

class Plot {
    int length, width;

public:
    // Constructor
    Plot(int l = 0, int w = 0) {
        length = l;
        width = w;
    }

    // Operator overloading (+)
    Plot operator + (Plot p) {
        Plot temp;
        temp.length = length + p.length;
        temp.width  = width + p.width;
        return temp;
    }

    // Display function
    void display() {
        cout << "Plot: " << length << " x " << width << endl;
        cout << "Area: " << length * width << endl;
    }
};

int main() {
    // Create two plots
    Plot p1(10, 5);
    Plot p2(6, 3);

    // Add plots using overloaded operator
    Plot p3 = p1 + p2;

    // Display result
    cout << "Combined Plot:\n";
    p3.display();

    return 0;
}

Run-Time (Dynamic) Polymorphism

Run-time polymorphism means the function that gets executed is determined at runtime, not compile time. This is achieved through function overriding using virtual functions and pointers/references to base classes.

Function Overriding Example

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() {
        cout << "Dog barks" << endl;
    }
};

class Cat : public Animal {
public:
    void sound() {
        cout << "Cat meows" << endl;
    }
};

int main() {
    Animal* a;   // Base class pointer
    Dog d;
    Cat c;

    a = &d;
    a->sound();   // Calls Dog’s sound()

    a = &c;
    a->sound();   // Calls Cat’s sound()

    return 0;
}

Why Do We Use Pointers in Polymorphism?

When we call a virtual function using an object (e.g., obj.sound()), the compiler already knows its type, so it doesn’t check at runtime. But when we call it through a base class pointer or reference, C++ checks which object the pointer actually refers to and calls the correct version. Hence, pointers or references are used to achieve real dynamic behavior.

Difference Between Function Overloading and Function Overriding

Real-World Example: Draw Function

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a shape" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Drawing a circle" << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() {
        cout << "Drawing a rectangle" << endl;
    }
};

int main() {
    Shape* shape;
    Circle c;
    Rectangle r;

    shape = &c;
    shape->draw();

    shape = &r;
    shape->draw();

    return 0;
}

Output:

Drawing a circle
Drawing a rectangle

Advantages of Polymorphism

1. Code Reusability: Once a base class or function is written, it can be reused by derived classes without rewriting code. This reduces redundancy and saves development time.
2. Flexibility: Polymorphism allows one interface to handle multiple types of behavior. For example, a single pointer of a base class can call different functions depending on which derived object it points to.
3. Scalability: New classes and behaviors can be added easily without modifying existing code. This makes software easier to extend and maintain.
4. Readability: Code becomes more organized and easier to understand since similar actions are grouped under the same interface or function name.

Key Points to Remember

• Polymorphism = One interface, many implementations.
• Function Overloading and Operator Overloading → Compile-time polymorphism.
• Function Overriding using virtual → Run-time polymorphism.
• Use base class pointers or references to achieve dynamic behavior.
• Destructors in base classes should be declared virtual to ensure proper cleanup.