Virtual Functions in C++ Explained — Polymorphism, vtables and Real-World Patterns

#include <iostream>
#include <string>

// --- WITHOUT virtual: static dispatch, wrong behaviour ---
class AnimalBase {
public:
    // No virtual keyword — compiler resolves this at compile time
    void speak() const {
        std::cout << "[AnimalBase] Some generic animal sound\n";
    }
};

class DogStatic : public AnimalBase {
public:
    // This OVERRIDES in the programmer's mind, but NOT polymorphically
    void speak() const {
        std::cout << "[DogStatic] Woof!\n";
    }
};

// --- WITH virtual: dynamic dispatch, correct behaviour ---
class Animal {
public:
    // virtual keyword tells C++: resolve this call at RUNTIME
    virtual void speak() const {
        std::cout << "[Animal] Some generic animal sound\n";
    }

    // Always virtual in a polymorphic base class (more on this later)
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    // override keyword is your safety net — compiler errors if signature doesn't match
    void speak() const override {
        std::cout << "[Dog] Woof!\n";
    }
};

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

void makeAnimalSpeak(const Animal* animal) {
    // We don't know if this is a Dog, Cat, or something else — and we don't care
    animal->speak(); // vtable lookup happens HERE at runtime
}

int main() {
    std::cout << "=== Without virtual (static dispatch) ===\n";
    AnimalBase* staticAnimal = new DogStatic(); // pointer type is AnimalBase*
    staticAnimal->speak(); // calls AnimalBase::speak() — WRONG!
    delete staticAnimal;

    std::cout << "\n=== With virtual (dynamic dispatch) ===\n";
    Animal* dog = new Dog();
    Animal* cat = new Cat();

    makeAnimalSpeak(dog); // vtable says: call Dog::speak()
    makeAnimalSpeak(cat); // vtable says: call Cat::speak()

    delete dog;
    delete cat;

    return 0;
}

#include <iostream>

// Demonstrates vptr memory overhead and vtable-driven dispatch
class Shape {
public:
    virtual double area() const {
        return 0.0;
    }

    virtual double perimeter() const {
        return 0.0;
    }

    virtual void describe() const {
        std::cout << "I am a generic shape\n";
    }

    virtual ~Shape() = default;
};

class Circle : public Shape {
private:
    double radius;
public:
    explicit Circle(double r) : radius(r) {}

    // Each override replaces the corresponding vtable SLOT for Circle's vtable
    double area() const override {
        return 3.14159265 * radius * radius;
    }

    double perimeter() const override {
        return 2.0 * 3.14159265 * radius;
    }

    void describe() const override {
        std::cout << "I am a Circle with radius " << radius << "\n";
    }
};

class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double area() const override {
        return width * height;
    }

    double perimeter() const override {
        return 2.0 * (width + height);
    }

    void describe() const override {
        std::cout << "I am a Rectangle " << width << "x" << height << "\n";
    }
};

// This function works for ANY Shape subtype — written once, open to extension
void printShapeInfo(const Shape& shape) {
    shape.describe();                  // resolved via vptr at runtime
    std::cout << "  Area      : " << shape.area() << "\n";
    std::cout << "  Perimeter : " << shape.perimeter() << "\n";
}

int main() {
    // sizeof shows the vptr overhead: Shape is not empty even with no data members
    std::cout << "sizeof(Shape)     = " << sizeof(Shape) << " bytes\n";
    std::cout << "sizeof(Circle)    = " << sizeof(Circle) << " bytes\n";
    std::cout << "sizeof(Rectangle) = " << sizeof(Rectangle) << " bytes\n\n";

    Circle    bigCircle(7.0);
    Rectangle door(0.9, 2.1);

    printShapeInfo(bigCircle);  // vptr points to Circle's vtable
    std::cout << "\n";
    printShapeInfo(door);       // vptr points to Rectangle's vtable

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// Abstract base class — models the CONCEPT of a payment gateway
// Cannot be instantiated: new PaymentGateway() would be a compile error
class PaymentGateway {
public:
    // Pure virtual — every concrete gateway MUST implement this
    virtual bool processPayment(double amountUSD) = 0;

    // Pure virtual — must be implemented, returns gateway name for logging
    virtual std::string gatewayName() const = 0;

    // Non-pure virtual with shared logic all gateways inherit
    virtual void logTransaction(double amountUSD, bool success) const {
        std::cout << "[" << gatewayName() << "] "
                  << (success ? "SUCCESS" : "FAILED")
                  << " — $" << amountUSD << "\n";
    }

    // Virtual destructor is MANDATORY in any polymorphic base class
    virtual ~PaymentGateway() = default;
};

class StripeGateway : public PaymentGateway {
private:
    std::string apiKey;
public:
    explicit StripeGateway(const std::string& key) : apiKey(key) {}

    bool processPayment(double amountUSD) override {
        // Real code would make an HTTP call here
        bool success = (amountUSD < 10000.0); // simulate limit
        logTransaction(amountUSD, success);   // calls shared base implementation
        return success;
    }

    std::string gatewayName() const override {
        return "Stripe";
    }
};

class PayPalGateway : public PaymentGateway {
private:
    std::string merchantId;
public:
    explicit PayPalGateway(const std::string& id) : merchantId(id) {}

    bool processPayment(double amountUSD) override {
        bool success = (amountUSD < 5000.0); // PayPal has tighter limit here
        logTransaction(amountUSD, success);
        return success;
    }

    std::string gatewayName() const override {
        return "PayPal";
    }
};

// This billing engine knows NOTHING about Stripe or PayPal — only PaymentGateway
// Adding a new gateway (Braintree, Square) requires zero changes here
void runBillingCycle(PaymentGateway& gateway, const std::vector<double>& charges) {
    std::cout << "--- Billing cycle via " << gateway.gatewayName() << " ---\n";
    for (double charge : charges) {
        gateway.processPayment(charge);
    }
    std::cout << "\n";
}

int main() {
    // unique_ptr handles memory automatically — no manual delete needed
    auto stripe = std::make_unique<StripeGateway>("sk_live_abc123");
    auto paypal = std::make_unique<PayPalGateway>("merchant_xyz");

    std::vector<double> monthlyCharges = {29.99, 199.00, 6500.00};

    runBillingCycle(*stripe, monthlyCharges);
    runBillingCycle(*paypal, monthlyCharges);

    return 0;
}

#include <iostream>

// === BROKEN: non-virtual destructor — memory leak waiting to happen ===
class SensorBase {
public:
    SensorBase()  { std::cout << "[SensorBase] constructed\n"; }
    // BUG: non-virtual destructor — derived destructor will NOT be called
    ~SensorBase() { std::cout << "[SensorBase] destroyed\n"; }

    virtual void readData() const {
        std::cout << "[SensorBase] reading...\n";
    }
};

class TemperatureSensor : public SensorBase {
private:
    int* calibrationBuffer; // simulates heap resource
public:
    TemperatureSensor() {
        calibrationBuffer = new int[256]; // allocates memory
        std::cout << "[TemperatureSensor] constructed, buffer allocated\n";
    }
    // This NEVER runs if deleted through a SensorBase* (non-virtual base destructor)
    ~TemperatureSensor() {
        delete[] calibrationBuffer;       // memory freed here — but only if called!
        std::cout << "[TemperatureSensor] destroyed, buffer freed\n";
    }
    void readData() const override {
        std::cout << "[TemperatureSensor] 23.4 degrees Celsius\n";
    }
};

// === FIXED: virtual destructor — correct cleanup guaranteed ===
class DeviceBase {
public:
    DeviceBase()  { std::cout << "[DeviceBase] constructed\n"; }
    virtual ~DeviceBase() { std::cout << "[DeviceBase] destroyed\n"; } // FIXED

    virtual void activate() const {
        std::cout << "[DeviceBase] activating...\n";
    }
};

class GPSDevice : public DeviceBase {
private:
    double* waypointCache;
public:
    GPSDevice() {
        waypointCache = new double[512];
        std::cout << "[GPSDevice] constructed, waypoint cache allocated\n";
    }
    ~GPSDevice() override {
        delete[] waypointCache; // this WILL run because DeviceBase destructor is virtual
        std::cout << "[GPSDevice] destroyed, waypoint cache freed\n";
    }
    void activate() const override {
        std::cout << "[GPSDevice] GPS lock acquired\n";
    }
};

int main() {
    std::cout << "=== BROKEN (non-virtual destructor) ===\n";
    SensorBase* brokenSensor = new TemperatureSensor();
    brokenSensor->readData();
    delete brokenSensor; // TemperatureSensor::~TemperatureSensor() is SKIPPED — leak!

    std::cout << "\n=== FIXED (virtual destructor) ===\n";
    DeviceBase* gps = new GPSDevice();
    gps->activate();
    delete gps; // GPSDevice::~GPSDevice() runs FIRST, then DeviceBase::~DeviceBase()

    return 0;
}