Polymorphism: Compile-Time & Run-Time (Function Overloading, Virtual Functions)

One of the most fascinating and powerful pillars of Object-Oriented Programming is Polymorphism. The term comes from the Greek words “poly” (many) and “morph” (form), essentially meaning many forms. In C++, polymorphism allows the same interface to be used for different underlying forms (data types or behaviors), enhancing flexibility, modularity, and reusability of code.

In this advanced yet beginner-friendly blog by Kamlesh Singad from Code With Kamlesh, we explore Polymorphism in C++ in both its compile-time and run-time forms. You’ll learn through clear theory and practical examples how Function Overloading and Virtual Functions bring polymorphism to life.

What is Polymorphism in C++?

It is the ability of a function, object, or operator to behave differently based on the context. In C++, polymorphism can be broadly categorized into two types:

• Compile-Time Polymorphism (Static Binding)
• Run-Time Polymorphism (Dynamic Binding)

Also Read: Smart Pointers in C++: Unique, Shared, and Weak Pointers

Compile-Time Polymorphism

1. Function Overloading

Function overloading occurs when two or more functions in the same scope have the same name but different parameter lists.

class Print {
public:
    void show(int i) {
        cout << "Integer: " << i << endl;
    }

    void show(double d) {
        cout << "Double: " << d << endl;
    }

    void show(string s) {
        cout << "String: " << s << endl;
    }
};

Key Points:

• Functions must differ in type or number of parameters.
• Return type alone is not enough to differentiate functions.
• Decision is made at compile time.

Also Read: Dynamic Memory Allocation (malloc, calloc, free, new, delete) in C/C++

2. Operator Overloading

You can redefine the behavior of operators for user-defined data types.

class Complex {
public:
    int real, imag;

    Complex(int r, int i) : real(r), imag(i) {}

    Complex operator + (Complex const &c) {
        return Complex(real + c.real, imag + c.imag);
    }
};

Note: While powerful, operator overloading should be used carefully to maintain code clarity.

Run-Time Polymorphism

1. Virtual Functions

Virtual functions allow you to achieve dynamic (run-time) method dispatch. A virtual function is defined in the base class and overridden in the derived class.

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

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

2. Base Class Pointer, Derived Class Object

Animal* a;
Dog d;
a = &d;
a->sound(); // Outputs: Bark

Here, despite the pointer being of type Animal*, it calls Dog’s version of sound() due to the virtual keyword.

Also Read: Pointer Arithmetic & Pointer Arrays in C/C++

Virtual Function Rules and Behaviors

• Virtual functions must be declared in the base class.
• Only non-static member functions can be virtual.
• Constructors can’t be virtual, but destructors should be virtual in polymorphic base classes.
• If a class has virtual functions, always use a virtual destructor to avoid resource leaks.

Abstract Classes and Pure Virtual Functions

An abstract class is one that contains at least one pure virtual function.

class Shape {
public:
    virtual void draw() = 0; // Pure virtual
};

Derived classes must override all pure virtual functions to be instantiated.

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

Real-World Example: Payment System

class Payment {
public:
    virtual void pay() {
        cout << "Generic Payment" << endl;
    }
};

class CreditCard : public Payment {
public:
    void pay() override {
        cout << "Paid by Credit Card" << endl;
    }
};

class PayPal : public Payment {
public:
    void pay() override {
        cout << "Paid via PayPal" << endl;
    }
};

void processPayment(Payment* p) {
    p->pay();
}

Using processPayment(new CreditCard()) vs processPayment(new PayPal()) produces different outputs, showcasing polymorphism.

Polymorphism in File Handling and OOP Systems

It also plays a huge role in systems that depend on modularity:

• File readers for different formats (.txt, .csv, .json)
• GUI systems where buttons, sliders, and checkboxes share a common interface
• Game objects: Enemy, Player, Obstacle all inherit from GameObject

Polymorphism and Memory Management

Virtual Destructors

class Base {
public:
    virtual ~Base() {
        cout << "Base destructor\n";
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor\n";
    }
};

Base* obj = new Derived();
delete obj; // Both destructors called

If the destructor in the base class is not virtual, only the base class destructor is called, leading to memory leaks.

Best Practices for Polymorphism

• Always use virtual destructors when using base pointers.
• Keep interfaces clean and intuitive.
• Avoid excessive function overloading—it can confuse readers.
• Use override keyword for better clarity and compiler checks.
• Favor composition over inheritance where possible for better flexibility.

Common Mistakes in Polymorphism

• Forgetting to declare a virtual destructor.
• Overloading functions incorrectly (ambiguous signature).
• Misunderstanding compile-time vs run-time behavior.
• Calling virtual functions inside constructors/destructors (discouraged).
• Assuming return type can distinguish overloaded functions (it can’t).

FAQs

What is the main difference between compile-time and run-time polymorphism?
Compile-time polymorphism is resolved during compilation (like function overloading), while run-time polymorphism is resolved during program execution (like virtual functions).

Can constructors be virtual in C++?
No, constructors cannot be virtual.

What happens if you don’t use virtual destructor in base class?
Only the base destructor will execute, possibly leading to memory leaks in derived classes.

Can function overloading be done across different classes?
No, function overloading applies within the same scope. Across classes, it’s function overriding (if using inheritance).

Is function overriding an example of polymorphism?
Yes, it’s an example of run-time polymorphism.

Can we overload a function with the same number of parameters?
Yes, but the types of parameters must be different.

Conclusion

Polymorphism is not just a topic in Object-Oriented Programming—it is a fundamental principle that enables scalable and extensible software development. Whether you’re designing a payment gateway system or building an interactive GUI, understanding both function overloading and virtual functions gives you the power to write clean, dynamic, and efficient code.

Under the expert guidance of Kamlesh Singad from Code With Kamlesh, you now have a practical and in-depth understanding of Polymorphism in C++. Keep coding, keep experimenting, and keep improving!