What is Polymorphism in C++?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Identify the shared interface

   Define a common base class or overloaded name that many types will implement.

2. Step 2

   Choose static or dynamic

   Use overloading and templates for compile-time polymorphism, or virtual functions for run-time polymorphism.

3. Step 3

   Implement per-type behavior

   Each derived class or overload supplies its own version of the operation.

4. Step 4

   Call through the common interface

   Invoke the shared name so the appropriate implementation is selected by type.

5. Step 5

   Rely on resolution

   Let the compiler resolve static calls and the vtable resolve virtual calls at run time.

Code Example

#include <iostream>

// Compile-time polymorphism: function overloading
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

// Run-time polymorphism: virtual functions
class Animal {
public:
    virtual void speak() const { std::cout << "...\n"; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "Woof\n"; }
};

class Cat : public Animal {
public:
    void speak() const override { std::cout << "Meow\n"; }
};

void describe(const Animal& a) { a.speak(); }  // resolves at run time

int main() {
    std::cout << add(2, 3) << '\n';       // int overload
    std::cout << add(2.5, 3.5) << '\n';   // double overload
    Dog d; Cat c;
    describe(d);
    describe(c);
}

Follow-up Questions

• What is the difference between compile-time and run-time polymorphism?
• How do templates provide static polymorphism?
• What is the difference between overloading and overriding?
• Why does dynamic polymorphism require pointers or references?
• What is the performance tradeoff between virtual calls and templates?