C++ Polymorphism

What Is Polymorphism?

In C++, polymorphism allows one interface to take on multiple forms, enabling different data types or classes to be accessed through a common reference. It allows objects of various classes to be treated through a common interface, enabling the same function call to execute different behaviors depending on the object it’s working with.

Simply put, polymorphism lets one name stand for many different actions, depending on the context.

Why Is Polymorphism Useful?

• It promotes flexible and reusable code.
• Allows the program to determine at runtime which specific function should be invoked.
• Supports extensibility without changing existing code.
• Simplifies code by handling different data types or classes uniformly.

Types of Polymorphism in C++

1. Compile-Time Polymorphism (Static binding)

Achieved via function overloading or operator overloading.

2. Run-Time Polymorphism (Dynamic binding)

Achieved via virtual functions and inheritance, allowing behavior to be decided during program execution.

Simple Example: Run-Time Polymorphism with Virtual Functions

#include 
using namespace std;

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

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

class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing a square." << endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw();  // Calls Circle's draw()
    shape2->draw();  // Calls Square's draw()

    delete shape1;
    delete shape2;

    return 0;
}

How This Works

• The base class Shape has a function draw(), marked as virtual. This means the exact function to run will be picked when the program is running, not earlier.
• Objects of derived classes Circle and Square override the draw() method to provide specific implementations.
• Although both shape1 and shape2 are pointers of type Shape*, they call their respective overridden versions of draw(), showing different results depending on the actual object type.

Final Thoughts on Polymorphism

Polymorphism is like a universal remote control that adjusts its functions based on the device it’s pointing to. In C++, it ensures your programs can handle diverse objects seamlessly, responding correctly to each one’s unique behavior without needing separate function calls for every type.