Hva er diamantproblemet i multipel arv?

Question

Accepted Answer

**Diamantproblemet** oppstår når en klasse arver fra to klasser som deler en felles forgjenger, noe som skaper tvetydighet: hvis begge midtkklassene overstyrer en metode (eller holder et felt), hvilken versjon får bunnklassen?

## Diamanten

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

## I Python (som tillater multipel arv)

```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øser det deterministisk via **Method Resolution Order (MRO)** ved hjelp av C3-linearisering, og `super()` samarbeider med den rekkefølgen.

## Hvordan språk håndterer det

| Språk | Tilnærming |
|---|---|
| C++ | Tillater det; tvetydighet er en kompileringsfeil med mindre du kvalifiserer, eller bruker `virtual` arv for å dele en base |
| Java/C# | **Forbyr** multipel klassearv; tillater flere *interfaces* (ingen tilstand, så ingen diamant av data) |
| Python | Tillater det; løser via MRO (C3) |
| Scala | **Traits** med en definert lineariseringsrekkefølge |

## Felle

Even med en MRO blir multipel arv av *tilstand* forvirrende raskt — duplisert base-initialisering, overraskende `super()` kjeder. Interfaces/traits (oppførsel, ikke tilstand) unngår det meste av problemet.

## Hvorfor det betyr noe

Det forklarer en stor deling av språkdesign: Java og C# forbudte multipel klassearv spesifikt for å unngå denne tvetydigheten, og tilbyr interfaces i stedet.

Å forstå MRO er praktisk i Python: samarbeidende `super()` og mixin-rekkefølge gir kun mening når du ser hvordan diamanten blir linearisert.

Språk	Tilnærming
C++	Tillater det; tvetydighet er en kompileringsfeil med mindre du kvalifiserer, eller bruker `virtual` arv for å dele en base
Java/C#	Forbyr multipel klassearv; tillater flere interfaces (ingen tilstand, så ingen diamant av data)
Python	Tillater det; løser via MRO (C3)
Scala	Traits med en definert lineariseringsrekkefølge