What is the diamond problem in multiple inheritance?

Question

Accepted Answer

The **diamond problem** arises when a class inherits from two classes that share a common ancestor, creating ambiguity: if both middle classes override a method (or hold a field), which version does the bottom class get?

## The diamond

```text
        A  (defines greet())
       / \
      B   C   (each may override greet())
       \ /
        D   ← inherits from B and C: which greet()?
```

## In Python (which allows multiple inheritance)

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                  # multiple inheritance
    pass

print(D().greet())             # "B"  — resolved by MRO, not ambiguous
print(D.__mro__)               # D → B → C → A → object  (C3 linearization)
```

Python resolves it deterministically via the **Method Resolution Order (MRO)** using C3 linearization, and `super()` cooperates with that order.

## How languages handle it

| Language | Approach |
|---|---|
| C++ | Allows it; ambiguity is a compile error unless you qualify, or use `virtual` inheritance to share one base |
| Java/C# | **Forbid** multiple class inheritance; allow multiple *interfaces* (no state, so no diamond of data) |
| Python | Allows it; resolves via MRO (C3) |
| Scala | **Traits** with a defined linearization order |

## Pitfall

Even with an MRO, multiple inheritance of *state* gets confusing fast — duplicated base initialization, surprising `super()` chains. Interfaces/traits (behavior, not state) sidestep most pain.

## Why it matters

It explains a major language design fork: Java and C# banned multiple class inheritance specifically to avoid this ambiguity, offering interfaces instead.

Understanding the MRO is practical in Python: cooperative `super()` and mixin ordering only make sense once you see how the diamond is linearized.

Language	Approach
C++	Allows it; ambiguity is a compile error unless you qualify, or use `virtual` inheritance to share one base
Java/C#	Forbid multiple class inheritance; allow multiple interfaces (no state, so no diamond of data)
Python	Allows it; resolves via MRO (C3)
Scala	Traits with a defined linearization order