Polymorphism

Section: C++ OOP. C++ polymorphism — one interface, many forms: compile-time overloading and runtime virtual dispatch.

#include <iostream>
using namespace std;

void print(int x) {
    cout << "int: " << x << "\n";
}
void print(double x) {
    cout << "double: " << x << "\n";
}
void print(const char* s) {
    cout << "string: " << s << "\n";
}
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

int main() {
    print(10);        // int overload
    print(3.14);      // double overload
    print("Hello");   // const char* overload
    cout << add(2, 3) << "\n";       // 5
    cout << add(2.5, 3.1) << "\n";   // 5.6
    return 0;
}

#include <iostream>
using namespace std;

class Complex {
    double re, im;
public:
    Complex(double r = 0, double i = 0) : re(r), im(i) {}
    Complex operator+(const Complex& o) const {
        return Complex(re + o.re, im + o.im);
    }
    void show() const { cout << re << " + " << im << "i\n"; }
};

int main() {
    Complex a(1, 2), b(3, 4);
    Complex c = a + b; // operator+ overload
    c.show();          // 4 + 6i
    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << maximum(10, 20) << "\n";       // int
    cout << maximum(2.5, 1.5) << "\n";     // double
    cout << maximum('a', 'z') << "\n";     // char
    return 0;
}

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() const { cout << "Shape\n"; }
    virtual ~Shape() = default;
};
class Circle : public Shape {
public:
    void draw() const override { cout << "Circle\n"; }
};
class Rectangle : public Shape {
public:
    void draw() const override { cout << "Rectangle\n"; }
};

int main() {
    Circle c;
    Rectangle r;
    Shape* p;
    p = &c; p->draw(); // Circle  (runtime)
    p = &r; p->draw(); // Rectangle
    return 0;
}

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};
class Triangle : public Shape {
public:
    void draw() const override { cout << "Triangle\n"; }
};
class Line : public Shape {
public:
    void draw() const override { cout << "Line\n"; }
};

void render(const Shape& s) {
    s.draw(); // runtime choice
}

int main() {
    Triangle t;
    Line L;
    render(t);
    render(L);
    return 0;
}

• Polymorphism = many forms of one interface.
• Compile-time: overloading + templates; runtime: virtual.
• Overloading → different params; overriding → same signature + virtual.
• operator+ is still compile-time polymorphism.
• Runtime needs Base* / Base& to a derived object.
• Always use override on intended overrides.
• Polymorphic base ⇒ virtual destructor.
• Return type alone cannot overload functions.
• Templates = static polymorphism used by the STL.
• If types are fixed and known, prefer overloads/templates for speed.
• If behaviour must vary by dynamic type, use virtuals.
• Practice one overload example and one virtual example for interviews.

1. Write three overloads of display() for int, double, and string.
2. Overload operator+ for a Complex or Point class.
3. Write a template max(a,b) and call it with int and double.
4. Implement Shape with virtual draw(); Circle and Rectangle overrides.
5. Pass Shape& to a render() function; call with different shapes.
6. Build Payment with pay(); UpiPay and CardPay; checkout via base reference.
7. Show a non-virtual base call vs virtual call side by side.
8. Create a table in comments: compile-time vs runtime with your own examples.
9. Intentionally mismatch an override signature; fix it using override.
10. Store several Animal* and call speak() in a loop.
11. Overload a constructor set (default / parameterized) — note it is compile-time.
12. Explain when you would pick templates instead of a virtual hierarchy.