Polymorphism in C++ Explained: Static vs Dynamic with Real Examples

#include <iostream>
#include <string>

// --- Function Overloading ---
// Same function name, different parameter types.
// The compiler resolves which one to call at compile time.

void displayValue(int number) {
    std::cout << "Integer: " << number << "\n";
}

void displayValue(double decimal) {
    std::cout << "Double: " << decimal << "\n";
}

void displayValue(const std::string& text) {
    std::cout << "String: " << text << "\n";
}

// --- Function Template ---
// One definition, works for any type T that supports operator+.
// The compiler generates a concrete version for each type you use.

template <typename T>
T addTwo(T first, T second) {
    return first + second;  // Works for int, double, std::string — anything with operator+
}

int main() {
    // Overloaded calls — compiler picks the right version based on argument type
    displayValue(42);           // Calls displayValue(int)
    displayValue(3.14);         // Calls displayValue(double)
    displayValue(std::string("Hello, Forge!"));  // Calls displayValue(string)

    std::cout << "\n";

    // Template calls — compiler stamps out addTwo<int> and addTwo<double> separately
    std::cout << "Int sum:    " << addTwo(10, 20)        << "\n";
    std::cout << "Double sum: " << addTwo(1.5, 2.5)      << "\n";
    std::cout << "Concatenated: " << addTwo(std::string("Hello "), std::string("World")) << "\n";

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>   // for std::unique_ptr — no raw new/delete in modern C++
#include <cmath>    // for M_PI

// Base class defines the CONTRACT.
// Any shape must be able to report its area and describe itself.
class Shape {
public:
    // 'virtual' tells the compiler: resolve this call at runtime, not compile time.
    virtual double area() const = 0;          // Pure virtual — Shape is now abstract
    virtual void   describe() const = 0;      // Subclasses MUST override this

    // CRITICAL: virtual destructor ensures derived destructors are called correctly
    // when deleting through a base-class pointer.
    virtual ~Shape() {
        std::cout << "[Shape destructor called]\n";
    }
};

class Circle : public Shape {
public:
    explicit Circle(double radius) : radius_(radius) {}

    // 'override' keyword — lets the compiler catch typos in the function signature
    double area() const override {
        return M_PI * radius_ * radius_;
    }

    void describe() const override {
        std::cout << "Circle with radius " << radius_
                  << " | Area: " << area() << "\n";
    }

    ~Circle() override {
        std::cout << "[Circle destructor called]\n";
    }

private:
    double radius_;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}

    double area() const override {
        return width_ * height_;
    }

    void describe() const override {
        std::cout << "Rectangle " << width_ << "x" << height_
                  << " | Area: " << area() << "\n";
    }

    ~Rectangle() override {
        std::cout << "[Rectangle destructor called]\n";
    }

private:
    double width_;
    double height_;
};

class Triangle : public Shape {
public:
    Triangle(double base, double height) : base_(base), height_(height) {}

    double area() const override {
        return 0.5 * base_ * height_;
    }

    void describe() const override {
        std::cout << "Triangle base=" << base_ << " height=" << height_
                  << " | Area: " << area() << "\n";
    }

    ~Triangle() override {
        std::cout << "[Triangle destructor called]\n";
    }

private:
    double base_;
    double height_;
};

// This function works for ANY shape — present or future.
// It doesn't know or care whether it's a Circle, Rectangle, or something you haven't written yet.
void printShapeInfo(const Shape& shape) {
    shape.describe();  // vtable dispatch happens here — correct method always called
}

int main() {
    // Store different shape types behind a common base-class pointer.
    // unique_ptr handles memory automatically — no manual delete.
    std::vector<std::unique_ptr<Shape>> canvas;

    canvas.push_back(std::make_unique<Circle>(5.0));
    canvas.push_back(std::make_unique<Rectangle>(4.0, 6.0));
    canvas.push_back(std::make_unique<Triangle>(3.0, 8.0));
    canvas.push_back(std::make_unique<Circle>(2.5));

    std::cout << "=== Shape Report ===\n";
    for (const auto& shape : canvas) {
        printShapeInfo(*shape);  // Runtime dispatch — correct describe() for each type
    }

    std::cout << "\nTotal shapes: " << canvas.size() << "\n";
    std::cout << "\n=== Cleanup (destructors) ===\n";
    // unique_ptrs go out of scope here — destructors fire in reverse order

    return 0;
}

#include <iostream>
#include <string>
#include <memory>
#include <stdexcept>

// Abstract base class — the CONTRACT every payment processor must honour.
// Cannot be instantiated directly. Pure virtual functions enforce implementation.
class PaymentProcessor {
public:
    // Every processor must implement these three operations
    virtual bool charge(const std::string& customerId, double amountUsd) = 0;
    virtual bool refund(const std::string& transactionId)                = 0;
    virtual std::string processorName() const                            = 0;

    // Concrete shared behaviour — all processors log the same way
    // Non-pure virtual: has a default implementation, but CAN be overridden
    virtual void logTransaction(const std::string& message) const {
        std::cout << "[" << processorName() << " LOG] " << message << "\n";
    }

    virtual ~PaymentProcessor() = default;  // Always virtual in polymorphic base classes
};

// --- Stripe Implementation ---
class StripeProcessor : public PaymentProcessor {
public:
    bool charge(const std::string& customerId, double amountUsd) override {
        // In reality this would call the Stripe REST API
        logTransaction("Charging $" + std::to_string(amountUsd) + " to customer " + customerId);
        std::cout << "  [Stripe] Payment authorised via card network\n";
        return true;  // Simulate success
    }

    bool refund(const std::string& transactionId) override {
        logTransaction("Refunding transaction " + transactionId);
        std::cout << "  [Stripe] Refund queued (3-5 business days)\n";
        return true;
    }

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

// --- PayPal Implementation ---
class PayPalProcessor : public PaymentProcessor {
public:
    bool charge(const std::string& customerId, double amountUsd) override {
        logTransaction("Charging $" + std::to_string(amountUsd) + " via PayPal wallet for " + customerId);
        std::cout << "  [PayPal] Deducted from PayPal balance\n";
        return true;
    }

    bool refund(const std::string& transactionId) override {
        logTransaction("Refunding PayPal transaction " + transactionId);
        std::cout << "  [PayPal] Refund issued instantly to PayPal balance\n";
        return true;
    }

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

    // Overrides the shared logging to add PayPal-specific formatting
    void logTransaction(const std::string& message) const override {
        std::cout << "[PayPal AUDIT TRAIL] " << message << "\n";
    }
};

// --- Checkout logic — knows NOTHING about Stripe or PayPal ---
// This function works for any current or future PaymentProcessor.
// Adding a new processor (e.g. CryptoProcessor) never touches this function.
void runCheckout(PaymentProcessor& processor, const std::string& customerId, double cartTotal) {
    std::cout << "\n--- Checkout for customer: " << customerId << " ---\n";
    std::cout << "Cart total: $" << cartTotal << "\n";

    bool success = processor.charge(customerId, cartTotal);  // vtable dispatch here

    if (success) {
        std::cout << "Payment successful!\n";
    } else {
        std::cout << "Payment failed. Please try another method.\n";
    }
}

int main() {
    StripeProcessor stripe;
    PayPalProcessor paypal;

    // Same checkout function, completely different processors — polymorphism in action
    runCheckout(stripe,  "cust_001", 149.99);
    runCheckout(paypal,  "cust_002", 39.50);

    // Adding a new processor later? Just create the class, call runCheckout.
    // Zero changes to runCheckout, zero changes to main's structure.

    std::cout << "\n--- Processing a refund ---\n";
    stripe.refund("txn_stripe_8821");

    return 0;
}

#include <iostream>
#include <memory>

// =============================================
// GOTCHA 1: Object Slicing
// =============================================

class Animal {
public:
    virtual std::string sound() const { return "..."; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    std::string sound() const override { return "Woof!"; }
};

void demonstrateSlicing() {
    Dog myDog;

    // CORRECT: pass by reference — virtual dispatch works, sound() returns "Woof!"
    Animal& animalRef = myDog;
    std::cout << "By reference: " << animalRef.sound() << "\n";  // "Woof!"

    // WRONG: copy by value — Dog is sliced down to Animal, losing override
    Animal slicedAnimal = myDog;  // Only the Animal portion is copied!
    std::cout << "By value (sliced): " << slicedAnimal.sound() << "\n";  // "..." — Bug!
}

// =============================================
// GOTCHA 2: Missing Virtual Destructor
// =============================================

class ResourceBase_WRONG {
public:
    // No virtual destructor — DANGEROUS if used polymorphically
    ~ResourceBase_WRONG() {
        std::cout << "ResourceBase_WRONG destructor\n";
    }
    virtual void use() { std::cout << "Base use\n"; }
};

class ResourceDerived_WRONG : public ResourceBase_WRONG {
public:
    ResourceDerived_WRONG() {
        heapBuffer_ = new int[1000];  // Allocate some resource
        std::cout << "ResourceDerived_WRONG: buffer allocated\n";
    }
    ~ResourceDerived_WRONG() {
        delete[] heapBuffer_;  // THIS NEVER FIRES if deleted via base pointer without virtual dtor
        std::cout << "ResourceDerived_WRONG destructor — buffer freed\n";
    }
private:
    int* heapBuffer_;
};

class ResourceBase_CORRECT {
public:
    virtual ~ResourceBase_CORRECT() {  // virtual destructor — ALWAYS do this in polymorphic bases
        std::cout << "ResourceBase_CORRECT destructor\n";
    }
    virtual void use() { std::cout << "Base use\n"; }
};

class ResourceDerived_CORRECT : public ResourceBase_CORRECT {
public:
    ResourceDerived_CORRECT() {
        heapBuffer_ = new int[1000];
        std::cout << "ResourceDerived_CORRECT: buffer allocated\n";
    }
    ~ResourceDerived_CORRECT() override {
        delete[] heapBuffer_;  // This DOES fire — derived destructor is called correctly
        std::cout << "ResourceDerived_CORRECT destructor — buffer freed\n";
    }
private:
    int* heapBuffer_;
};

void demonstrateDestructorBug() {
    std::cout << "\n--- BUG: Missing virtual destructor ---\n";
    ResourceBase_WRONG* bad = new ResourceDerived_WRONG();
    delete bad;  // Only ~ResourceBase_WRONG fires! Buffer leaks silently.

    std::cout << "\n--- FIX: Virtual destructor ---\n";
    ResourceBase_CORRECT* good = new ResourceDerived_CORRECT();
    delete good;  // Both destructors fire in the right order: derived first, then base.
}

int main() {
    std::cout << "=== GOTCHA 1: Slicing ===\n";
    demonstrateSlicing();

    std::cout << "\n=== GOTCHA 2: Destructor ===\n";
    demonstrateDestructorBug();

    return 0;
}