Qu'est-ce que le problème du diamant dans l'héritage multiple ?

Question

Accepted Answer

Le **problème du diamant** survient quand une classe hérite de deux classes qui partagent un ancêtre commun, créant une ambiguïté : si les deux classes intermédiaires surchargent une méthode (ou contiennent un champ), quelle version la classe inférieure obtient-elle ?

## Le diamant

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

## En Python (qui permet l'héritage multiple)

```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 le résout de manière déterministe via l'**ordre de résolution des méthodes (MRO)** en utilisant la linéarisation C3, et `super()` coopère avec cet ordre.

## Comment les langages le gèrent

| Langage | Approche |
|---|---|
| C++ | Le permet ; l'ambiguïté est une erreur de compilation sauf si vous qualifiez, ou utilisez l'héritage `virtual` pour partager une seule base |
| Java/C# | **Interdisent** l'héritage multiple de classes ; permettent l'héritage multiple d'*interfaces* (pas d'état, donc pas de diamant de données) |
| Python | Le permet ; résout via MRO (C3) |
| Scala | **Traits** avec un ordre de linéarisation défini |

## Pièges

Même avec un MRO, l'héritage multiple d'*état* devient confus rapidement — initialisation de base dupliquée, chaînes `super()` surprenantes. Les interfaces/traits (comportement, pas état) contournent la plupart des problèmes.

## Pourquoi c'est important

Cela explique un grand clivage dans la conception des langages : Java et C# ont interdit l'héritage multiple de classes spécifiquement pour éviter cette ambiguïté, en offrant des interfaces à la place.

Comprendre le MRO est pratique en Python : `super()` coopératif et l'ordre des mixins n'ont de sens qu'une fois que vous voyez comment le diamant est linéarisé.

Langage	Approche
C++	Le permet ; l'ambiguïté est une erreur de compilation sauf si vous qualifiez, ou utilisez l'héritage `virtual` pour partager une seule base
Java/C#	Interdisent l'héritage multiple de classes ; permettent l'héritage multiple d'interfaces (pas d'état, donc pas de diamant de données)
Python	Le permet ; résout via MRO (C3)
Scala	Traits avec un ordre de linéarisation défini