• Inheritance allows a new class (derived/child) to acquire properties and behaviors of an existing class (base/parent).
• It supports code reusability and forms a base-derived relationship.
• C++ supports: single, multiple, multilevel, hierarchical, and hybrid inheritance.

1) Base & Derived Class (Concept)

• Base class: existing class.
• Derived class: new class created from base class.
• Syntax: class Derived : access Base { };

#include <iostream>
using namespace std;

class A {
public:
    void showA() {
        cout << "Base class A" << endl;
    }
};

class B : public A {
public:
    void showB() {
        cout << "Derived class B" << endl;
    }
};

int main() {
    B obj;
    obj.showA();
    obj.showB();
    return 0;
}

2) Types of Inheritance

2.1) Single Inheritance

• One base → one derived.

class A { };
class B : public A { };

2.2) Multilevel Inheritance

• A → B → C (chain).

class A { };
class B : public A { };
class C : public B { };

2.3) Hierarchical Inheritance

• One base → multiple derived classes.

class A { };
class B : public A { };
class C : public A { };

2.4) Multiple Inheritance

• One derived inherits from multiple base classes.

class A { };
class B { };
class C : public A, public B { };

2.5) Hybrid Inheritance

• Combination of more than one inheritance type (example: multiple + multilevel).
• May create diamond problem, solved using virtual base class (advanced).

3) Constructors in Inheritance

• Base class constructor is called before derived class constructor.
• Destructor order is reverse: derived destructor first, then base destructor.
• Parameterized base constructor can be called using initializer list.

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base Constructor" << endl;
    }
};

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

int main() {
    Derived d;
    return 0;
}

#include <iostream>
using namespace std;

class Base {
    int x;
public:
    Base(int a) : x(a) {
        cout << "Base x = " << x << endl;
    }
};

class Derived : public Base {
public:
    Derived(int a) : Base(a) {
        cout << "Derived Constructor" << endl;
    }
};

int main() {
    Derived d(10);
    return 0;
}

4) Function Overriding

• When derived class provides its own version of a base class function with same signature.
• Used to achieve runtime polymorphism.

#include <iostream>
using namespace std;

class Base {
public:
    void show() {
        cout << "Base show()" << endl;
    }
};

class Derived : public Base {
public:
    void show() { // overriding
        cout << "Derived show()" << endl;
    }
};

int main() {
    Derived d;
    d.show();
    return 0;
}

5) virtual Keyword (Runtime Polymorphism)

• Without virtual, function call is decided at compile time (early binding).
• With virtual, function call is decided at runtime using base pointer/reference (late binding).

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base show()" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived show()" << endl;
    }
};

int main() {
    Base *p;
    Derived d;

    p = &d;     // base pointer points to derived object
    p->show();  // calls Derived show() because of virtual

    return 0;
}

6) Base-Derived Relationship (Important Notes)

• Derived class can access:
  • public members of base
  • protected members of base
  • Cannot directly access private members of base (use public/protected methods).
• Access mode effect:
  • public inheritance: base public stays public, protected stays protected
  • protected inheritance: base public/protected become protected
  • private inheritance: base public/protected become private

7) Quick Notes

• Inheritance improves code reuse and creates an is-a relationship.
• Overriding + virtual gives runtime polymorphism.
• Base constructor runs first, destructors run in reverse order.
• Multiple inheritance may cause ambiguity (diamond problem).