• Single inheritance: one derived class from one base class
• Multiple inheritance: one derived class from more than one base class (C++ supports this; some languages like Java do not, using interfaces instead)
• Access levels in inheritance: public (preserves accessibility), protected (accessible within class and derived classes, not outside), private (accessible only within the defining class)

class Animal { public: void eat() { cout << "eats\n"; } };
class Dog : public Animal { public: void bark() { cout << "barks\n"; } };
// Dog inherits eat() from Animal, adds bark() of its own

MCQ Trap: C++ supports multiple inheritance; many other OOP languages (e.g., Java) restrict classes to single inheritance and use interfaces instead.

What a derived class actually inherits

A derived class gets access to all public and protected members of its base class (not private — those stay locked to the base class itself, even for derived classes). It can then add new members and override existing behavior.

class Animal
{
  protected:
    string name;
public:
    Animal(string n) : name(n) {}
    void eat() { cout << name << " eats\n"; }
};

class Dog : public Animal
{
public:
    Dog(string n) : Animal(n) {}       // must call base constructor explicitly
    void bark() { cout << name << " barks\n"; }   // name accessible -- it's protected, not private
};

int main()
{
    Dog d("Rex");
    d.eat();    // inherited from Animal
    d.bark();   // Dog's own method
    return 0;
}

Constructor call order — base runs FIRST, always

When a Dog object is created, Animal's constructor runs before Dog's own constructor body executes. Destructors run in the opposite order (derived first, then base) — a common exam trap.

class A { public: A() { cout << "A constructed\n"; } ~A() { cout << "A destroyed\n"; } };
class B : public A { public: B() { cout << "B constructed\n"; } ~B() { cout << "B destroyed\n"; } };
// B b;  -->  Output: "A constructed", "B constructed", then on scope exit: "B destroyed", "A destroyed"

Inheritance access-level table (base access → resulting access in derived class)

public inheritance (class Dog : public Animal) is by far the most common — it preserves the "is-a" relationship cleanly.

Important MCQs

1. Which access specifier is NOT inherited/accessible at all in a derived class, regardless of inheritance type?
   • a) public b) protected c) private d) static
2. When a derived-class object is created, which constructor runs first?
   • a) Derived class's b) Base class's c) Both simultaneously d) Neither
3. Destructors, in an inheritance chain, run:
   • a) In the same order as constructors b) In the reverse order of constructors (derived first, then base) c) Randomly d) Never automatically
4. C++ supports multiple inheritance; which popular OOP language restricts classes to single inheritance and uses interfaces instead?
   • a) Python b) Java c) C++ d) PHP

Self-Test Questions