Wat is het diamantprobleem in meervoudige overerving?

Question

Accepted Answer

Het **diamantprobleem** ontstaat wanneer een klasse van twee klassen erft die een gemeenschappelijke voorouder delen, wat ambiguïteit creëert: als beide middelste klassen een methode overschrijven (of een veld bevatten), welke versie krijgt de onderste klasse?

## Het diamant

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

## In Python (wat meervoudige overerving toestaat)

```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 lost het deterministisch op via de **Method Resolution Order (MRO)** met C3-linearisatie, en `super()` werkt samen met die volgorde.

## Hoe talen het aanpakken

| Taal | Aanpak |
|---|---|
| C++ | Staat het toe; ambiguïteit is een compilatiefout tenzij je het kwalificeert, of `virtual` overerving gebruikt om één base te delen |
| Java/C# | **Verbieden** meervoudige klassenover erving; staan meervoudige *interfaces* toe (geen state, dus geen diamant van data) |
| Python | Staat het toe; lost op via MRO (C3) |
| Scala | **Traits** met een gedefinieerde linearisatievolgorde |

## Valkuil

Zelfs met een MRO wordt meervoudige overerving van *state* snel verwarrend — gedupliceerde basis-initialisatie, verrassende `super()` ketens. Interfaces/traits (gedrag, niet state) omzeilen het meeste gedoe.

## Waarom het belangrijk is

Het verklaart een grote ontwerpkeuze in talen: Java en C# hebben meervoudige klassenover erving specifiek verboden om deze ambiguïteit te voorkomen, en bieden in plaats daarvan interfaces aan.

Het begrijpen van de MRO is praktisch in Python: coöperatieve `super()` en mixin-ordening hebben alleen zin als je ziet hoe het diamant wordt gelineariseerd.

Taal	Aanpak
C++	Staat het toe; ambiguïteit is een compilatiefout tenzij je het kwalificeert, of `virtual` overerving gebruikt om één base te delen
Java/C#	Verbieden meervoudige klassenover erving; staan meervoudige interfaces toe (geen state, dus geen diamant van data)
Python	Staat het toe; lost op via MRO (C3)
Scala	Traits met een gedefinieerde linearisatievolgorde