Was ist das Diamantenproblem bei Mehrfachvererbung?

Question

Accepted Answer

Das **Diamantenproblem** tritt auf, wenn eine Klasse von zwei Klassen erbt, die einen gemeinsamen Vorfahren haben, was Mehrdeutigkeit erzeugt: Wenn beide mittleren Klassen eine Methode überschreiben (oder ein Feld halten), welche Version erhält die untere Klasse?

## Warum es wichtig ist

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

## In Python (das Mehrfachvererbung unterstützt)

```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 löst dies deterministisch über die **Method Resolution Order (MRO)** mithilfe von C3-Linearisierung, und `super()` arbeitet mit dieser Reihenfolge zusammen.

## Wie Sprachen damit umgehen

| Sprache | Ansatz |
|---|---|
| C++ | Erlaubt es; Mehrdeutigkeit ist ein Kompilierungsfehler, es sei denn, du qualifizierst ihn, oder verwendest `virtual` Vererbung, um eine Basis zu teilen |
| Java/C# | **Verbieten** Mehrfachklassenvererbung; erlauben mehrfache *Schnittstellen* (kein Status, also kein Diamant von Daten) |
| Python | Erlaubt es; löst via MRO (C3) |
| Scala | **Traits** mit einer definierten Linearisierungsreihenfolge |

## Falle

Auch mit einem MRO wird Mehrfachvererbung von *Status* schnell verwirrt — duplizierte Basis-Initialisierung, überraschende `super()`-Ketten. Schnittstellen/Traits (Verhalten, nicht Status) umgehen den meisten Schmerz.

## Warum es wichtig ist

Es erklärt einen großen Sprachdesign-Fork: Java und C# verboten Mehrfachklassenvererbung speziell, um diese Mehrdeutigkeit zu vermeiden, und bieten stattdessen Schnittstellen an.

Das Verstehen der MRO ist in Python praktisch: kooperatives `super()` und Mixin-Reihenfolge sind nur sinnvoll, wenn du erst siehst, wie der Diamant linearisiert wird.

Sprache	Ansatz
C++	Erlaubt es; Mehrdeutigkeit ist ein Kompilierungsfehler, es sei denn, du qualifizierst ihn, oder verwendest `virtual` Vererbung, um eine Basis zu teilen
Java/C#	Verbieten Mehrfachklassenvererbung; erlauben mehrfache Schnittstellen (kein Status, also kein Diamant von Daten)
Python	Erlaubt es; löst via MRO (C3)
Scala	Traits mit einer definierten Linearisierungsreihenfolge