C++ Inheritance & Polymorphism: All Types, Virtual Functions, vtable, override, final & DSA (2025)

#include <iostream>
#include <string>
using namespace std;

// ── Single Inheritance ─────────────────────────────────────────
class Animal {
protected:
    string name;
public:
    explicit Animal(string n) : name(move(n)) {}
    void breathe() const { cout << name << " breathes\n"; }
};

class Dog : public Animal {   // Single inheritance
public:
    explicit Dog(string n) : Animal(move(n)) {}
    void bark() const { cout << name << " barks!\n"; }
};

// ── Multilevel Inheritance ─────────────────────────────────────
class GuideDog : public Dog {  // Dog → Animal → GuideDog
public:
    explicit GuideDog(string n) : Dog(move(n)) {}
    void guide() const { cout << name << " guides owner\n"; }
};

// ── Hierarchical Inheritance ───────────────────────────────────
class Cat : public Animal {    // Cat and Dog both inherit Animal
public:
    explicit Cat(string n) : Animal(move(n)) {}
    void meow() const { cout << name << " meows!\n"; }
};

int main() {
    GuideDog gd("Buddy");
    gd.breathe();  // from Animal
    gd.bark();     // from Dog
    gd.guide();    // own method

    Dog d("Rex");  Cat c("Whiskers");
    d.breathe(); c.breathe();  // both inherit breathe()
    d.bark(); c.meow();
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

class Shape {
public:
    // virtual → runtime dispatch via vtable
    virtual void   draw() const            { cout << "Shape::draw\n"; }
    virtual double area() const noexcept  { return 0; }
    virtual        ~Shape() = default;   // MUST be virtual
};

class Circle : public Shape {
    double r;
public:
    explicit Circle(double radius) : r(radius) {}
    void   draw() const override        { cout << "Circle(r="<<r<<")\n"; }
    double area() const noexcept override{ return 3.14159*r*r; }
};

class Square : public Shape {
    double s;
public:
    explicit Square(double side) : s(side) {}
    void   draw() const override        { cout << "Square(s="<<s<<")\n"; }
    double area() const noexcept override{ return s*s; }
};

// Works for ANY Shape — current or future derived types
void printInfo(const Shape& s) {
    s.draw();                     // virtual → calls correct derived version
    cout << "  area=" << s.area() << "\n";
}

int main() {
    // Store heterogeneous shapes — unique_ptr for RAII
    vector<unique_ptr<Shape>> shapes;
    shapes.emplace_back(make_unique<Circle>(5.0));
    shapes.emplace_back(make_unique<Square>(4.0));
    shapes.emplace_back(make_unique<Circle>(3.0));

    for (const auto& s : shapes) printInfo(*s);

    // Without virtual: WRONG — always calls Shape::draw
    Shape* p = new Circle(2.0);
    p->draw();   // WITH virtual: Circle::draw ✓
    delete p;   // virtual dtor: ~Circle then ~Shape ✓
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

// Abstract class — cannot be instantiated directly
class Serializable {
public:
    virtual string serialize()   const = 0;   // pure virtual — MUST override
    virtual void   deserialize(const string&) = 0;
    virtual       ~Serializable() = default;

    // Non-pure virtual: has default, can override
    virtual string format() const { return "json"; }
};

// Concrete class — implements all pure virtuals → instantiable
class UserRecord : public Serializable {
    string name; int id;
public:
    UserRecord(string n, int i) : name(move(n)), id(i) {}
    string serialize() const override {
        return "{\"id\":" + to_string(id) + ",\"name\":\"" + name + "\"}";
    }
    void deserialize(const string& data) override {
        cout << "Deserializing: " << data << "\n";
    }
};

// ⚠ This would be a COMPILE ERROR:
// Serializable s; // Cannot instantiate abstract class

void save(const Serializable& obj) {
    cout << obj.format() << ": " << obj.serialize() << "\n";
}

int main() {
    UserRecord u("Alice", 42);
    save(u);  // json: {"id":42,"name":"Alice"}
    u.deserialize("{\"id\":43}");
    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    virtual void process() { cout << "Base::process\n"; }
    virtual void compute(int x) { cout << "Base::compute("<<x<<")\n"; }
    virtual ~Base() { cout << "~Base\n"; }  // MUST be virtual
};

class Derived : public Base {
public:
    // override: compile error if Base::process doesn't exist/is not virtual
    void process() override { cout << "Derived::process\n"; }

    // ⚠ Without override, this silently creates a NEW function (not override)
    // void compute(double x) { }  ← different signature — not an override!
    void compute(int x) override { cout << "Derived::compute("<<x<<")\n"; }

    // final: GrandChild cannot override this
    virtual void locked() final { cout << "Derived::locked\n"; }

    ~Derived() override { cout << "~Derived\n"; }
};

// final class — cannot be subclassed
class LeafNode final : public Derived { };
// class Bad : public LeafNode { };  ← COMPILE ERROR

int main() {
    Base* p = new Derived();
    p->process();   // Derived::process ← virtual dispatch
    p->compute(42); // Derived::compute ← virtual dispatch
    delete p;       // ~Derived then ~Base ← virtual destructor
    return 0;
}

#include <iostream>
using namespace std;

// ── Without virtual inheritance — PROBLEM ─────────────────────
class A { public: int x = 10; };
class B : public A {};
class C : public A {};
class D : public B, public C {
    // D has TWO copies of A::x — ambiguous!
    // D::x is a compile error — use B::x or C::x
};

// ── With virtual inheritance — SOLUTION ───────────────────────
class AV { public: int val = 42; void show() { cout << "val="<<val<<"\n"; } };
class BV : virtual public AV {};   // virtual inheritance
class CV : virtual public AV {};   // virtual inheritance
class DV : public BV, public CV {
public:
    // DV must directly initialize AV (the shared base)
    DV() : AV(), BV(), CV() {}
};

int main() {
    // Without virtual
    D d;
    cout << d.B::x << " " << d.C::x << endl;  // 10 10 — two separate copies
    d.B::x = 99;
    cout << d.B::x << " " << d.C::x << endl;  // 99 10 — B and C are independent

    // With virtual inheritance — ONE shared AV
    DV dv;
    dv.show();     // no ambiguity — only one AV
    dv.val = 100;
    dv.show();     // val=100 — single copy ✓
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

class Animal { public: virtual ~Animal()=default; virtual void speak()=0; };
class Dog : public Animal {
public:
    void speak() override { cout << "Woof!\n"; }
    void fetch() const   { cout << "Fetching!\n"; }  // Dog-specific
};
class Cat : public Animal { public: void speak() override { cout << "Meow!\n"; } };

int main() {
    // ── dynamic_cast — safe runtime downcast ─────────────────
    unique_ptr<Animal> a = make_unique<Dog>();
    a->speak();  // Woof! — virtual dispatch

    // Downcast to Dog* — safe (returns nullptr if not Dog)
    Dog* d = dynamic_cast<Dog*>(a.get());
    if (d) d->fetch();   // Fetching! — Dog-specific method

    // Downcast to Cat* — returns nullptr (not a Cat)
    Cat* c = dynamic_cast<Cat*>(a.get());
    if (!c) cout << "Not a Cat\n";

    // ── Object slicing — DANGER with pass-by-value ────────────
    Dog dog;
    Animal sliced = dog;  // SLICED — only Animal part copied!
    // sliced.speak() — would call Animal::speak, not Dog::speak
    // (speak is pure virtual, so this actually won't compile)
    // Fix: always use pointers or references for polymorphism
    Animal& ref = dog;
    ref.speak();  // Woof! — reference, no slicing
    return 0;
}