Polymorphism

Types of Polymorphism

1. Compile-time Polymorphism

Also known as static polymorphism. Resolved at compile time through function overloading and operator overloading:

Function Overloading

#include <iostream>
using namespace std;

class Calculator {
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() {
    Calculator calc;
    cout << calc.add(5, 3) << endl;        // int version
    cout << calc.add(5.5, 3.2) << endl;    // double version
    cout << calc.add(1, 2, 3) << endl;     // three parameters
    return 0;
}

Operator Overloading

#include <iostream>
using namespace std;

class Complex {
private:
    int real, imag;

public:
    Complex(int r = 0, int i = 0) {
        real = r;
        imag = i;
    }
    
    Complex operator + (const Complex &obj) {
        Complex res;
        res.real = real + obj.real;
        res.imag = imag + obj.imag;
        return res;
    }
    
    void display() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3, 4);
    Complex c2(1, 2);
    Complex c3 = c1 + c2;  // Operator overloading
    c3.display();
    return 0;
}

2. Runtime Polymorphism

Also known as dynamic polymorphism. Resolved at runtime through virtual functions:

Virtual Functions

Virtual functions allow runtime polymorphism. They are declared with the virtual keyword:

#include <iostream>
using namespace std;

class Base {
public:
    virtual void display() {  // Virtual function
        cout << "Base class display" << endl;
    }
};

class Derived : public Base {
public:
    void display() {  // Overrides base class function
        cout << "Derived class display" << endl;
    }
};

int main() {
    Base *ptr;
    Derived d;
    ptr = &d;
    
    ptr->display();  // Calls Derived::display() due to virtual
    
    return 0;
}

Pure Virtual Functions

A virtual function with no implementation. Makes the class abstract:

#include <iostream>
using namespace std;

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

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    void draw() {
        cout << "Drawing circle" << endl;
    }
    
    double area() {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double length, width;

public:
    Rectangle(double l, double w) : length(l), width(w) {}
    
    void draw() {
        cout << "Drawing rectangle" << endl;
    }
    
    double area() {
        return length * width;
    }
};

int main() {
    Shape *s1 = new Circle(5.0);
    Shape *s2 = new Rectangle(4.0, 6.0);
    
    s1->draw();
    cout << "Area: " << s1->area() << endl;
    
    s2->draw();
    cout << "Area: " << s2->area() << endl;
    
    delete s1;
    delete s2;
    return 0;
}

Abstract Classes

A class with at least one pure virtual function is called an abstract class. Objects of abstract classes cannot be created:

class AbstractClass {
public:
    virtual void pureFunction() = 0;  // Makes class abstract
    void concreteFunction() {
        cout << "This is a concrete function" << endl;
    }
};

// Cannot create: AbstractClass obj;  // Error!
// Must derive and implement pure virtual function

Virtual Destructor

When deleting objects through base class pointers, use virtual destructor to ensure proper cleanup:

#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() {  // Virtual destructor
        cout << "Base destructor" << endl;
    }
};

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

int main() {
    Base *ptr = new Derived();
    delete ptr;  // Calls both destructors due to virtual
    return 0;
}

Function Overriding vs Overloading