Ch 5. Inheritance

5 hours · 7 marks

5.1 Base Class and Derived Class

Inheritance lets a new class (derived/child class) acquire the properties (data members) and behaviour (member functions) of an existing class (base/parent class), promoting code reuse.

class Animal {              // base class
public:
    void eat() { cout << "Eating..."; }
};
class Dog : public Animal {  // derived class
public:
    void bark() { cout << "Barking..."; }
};
int main() {
    Dog d;
    d.eat();   // inherited from Animal
    d.bark();  // Dog's own
}

5.2 protected Access Specifier

protected members are accessible within the class itself and within any class derived from it, but NOT from outside the class (unlike public) — this makes it the typical choice for members that a base class wants to hide from the outside world but still share with subclasses.

5.3 Derived Class Declaration

class Derived : access-specifier Base {
    // additional members
};
// example:
class Manager : public Employee { ... };

5.4 Is-a Relation and Has-a Relation

5.5 Public, Protected and Private Inheritance

The access specifier used while inheriting controls how base class members appear in the derived class:

Private members of the base class are never directly accessible in the derived class regardless of the inheritance mode — they can only be accessed indirectly through public/protected base class methods.

5.6 Member Overriding

When a derived class defines a member function with the same name and signature as one in the base class, the derived class version "hides"/overrides it for objects of the derived type.

class Base {
public:
    void show() { cout << "Base::show"; }
};
class Derived : public Base {
public:
    void show() { cout << "Derived::show"; }   // overrides/hides Base::show
    void callBase() { Base::show(); }             // explicit call to base version
};

5.7 Forms of Inheritance

• Single inheritance: one derived class from one base class.
• Multiple inheritance: one derived class from two or more base classes: class C : public A, public B {};
• Multilevel inheritance: a chain — class C derived from B, which is derived from A.
• Hierarchical inheritance: multiple derived classes from a single base class.
• Hybrid inheritance: a combination of two or more forms above (e.g., hierarchical + multiple), which can lead to the diamond problem.

5.8 Constructors in Derived Class

When a derived object is created, the base class constructor is executed first, then the derived class constructor body runs. Arguments are passed to the base constructor using a member initialization list.

class Base {
public:
    Base(int x) { cout << "Base ctor " << x; }
};
class Derived : public Base {
public:
    Derived(int x, int y) : Base(x) {    // explicitly calling base ctor
        cout << " Derived ctor " << y;
    }
};
Derived d(1, 2);  // prints: Base ctor 1  Derived ctor 2

5.9 Destructor in Derived Class

Destructors execute in the reverse order of constructors — the derived class destructor runs first, then the base class destructor.

~Derived() { cout << "Derived dtor "; }
~Base() { cout << "Base dtor"; }
// output on object destruction: Derived dtor Base dtor

5.10 Need of Virtual Base Class

In multiple/hybrid inheritance, if two base classes both inherit from a common ancestor and a further class inherits from both, the common ancestor's members get duplicated (the diamond problem), causing ambiguity.

class Person { public: string name; };
class Student : virtual public Person { };   // virtual inheritance
class Employee : virtual public Person { };
class TeachingAssistant : public Student, public Employee { };
// with 'virtual', TeachingAssistant has only ONE copy of Person's members

Declaring the common base as a virtual base class ensures only a single shared copy of it exists in the most-derived object, eliminating ambiguity and duplication.

Most Probable Questions

class A { public: A() { cout << "A "; } };
class B : public A { public: B() { cout << "B "; } };
class C : public B { public: C() { cout << "C "; } };
int main() { C obj; }   // Output: A B C