Multiple Inheritance

A class inherits from more than one base class.

class A {
public:
    void foo() {}
};

class B {
public:
    void bar() {}
};

class C : public A, public B {
};

// C gets everything public/protected from both A and B.
C obj;
obj.foo(); // from A
obj.bar(); // from B

Why to use Multiple Inheritance ?

Mix independent capabilities

class Flyable {
public:
    void fly();
};

class Swimmable {
public:
    void swim();
};

class Duck : public Flyable, public Swimmable {
};

Diamond Problem

class Animal {
public:
    int age;
};

class Mammal : public Animal {};
class Bird   : public Animal {};

class Bat : public Mammal, public Bird {};

````````Animal
       /      \
  Mammal      Bird
       \      /
          Bat

Bat b;
b.age = 5; // 💥 ERROR: ambiguous

Why? Because Bat contains two copies of Animal.
1. One via Mammal
2. One via Bird

C++ refuses to guess which age you meant.

Virtual Inheritance

There should be only one shared Animal, no matter how we get there.

class Animal {
public:
    int age;
};

class Mammal : virtual public Animal {};
class Bird   : virtual public Animal {};

class Bat : public Mammal, public Bird {};

Bat b;
b.age = 5; // ✅ works

Only one Animal subobject exists.

When virtual inheritance is involved, the virtual base class is constructed by the most-derived class (bat here), not by the intermediate base classes.

class Mammal : virtual public Animal {
public:
    Mammal() : Animal(10) {}
};

class Bird : virtual public Animal {
public:
    Bird() : Animal(20) {}
};

class Bat : public Mammal, public Bird {
};

If both Mammal and Bird could initialize Animal, then:
- Which constructor should run?
- Animal(10) or Animal(20)?
- Both? That’s illegal.
- Pick one? That’s arbitrary.

So the language makes a rule: The most-derived class initializes the virtual base.

Initializing virtual base class

class Animal {
public:
    int age;

    Animal(int a) : age(a) {
        std::cout << "Animal constructed\n";
    }
};

class Mammal : virtual public Animal {
public:
    Mammal() : Animal(10) {   // ❌ ignored
        std::cout << "Mammal constructed\n";
    }
};

class Bird : virtual public Animal {
public:
    Bird() : Animal(20) {     // ❌ ignored
        std::cout << "Bird constructed\n";
    }
};

class Bat : public Mammal, public Bird {
public:
    Bat() : Animal(42), Mammal(), Bird() {
        std::cout << "Bat constructed\n";
    }
};

Construction order:

Animal(42) ← constructed ONCE, here
Mammal
Bird
Bat

Other Ambiguity

Even without shared bases, name clashes can happen.

class A {
public:
    void f();
};

class B {
public:
    void f();
};

class C : public A, public B {};

C obj;
obj.f(); // ❌ ambiguous

Solution 1: Scope resolution

obj.A::f();
obj.B::f();

Solution 2: Override

class C : public A, public B {
public:
    void f() {
        A::f(); // or custom logic
    }
};

Last modified: 08 February 2026