Rust: Implement Inheritance 3 Ways
Zusammenfassung
Kurz
Der Artikel zeigt anhand von Katze und Hund drei Rust-Muster: Ein `enum` bündelt bekannte Typvarianten, ein `trait` ermöglicht gemeinsames Verhalten, und Komposition teilt Daten wie einen Namen. Der Autor nennt Grenzen: Enum-Aufrufe brauchen eine explizite Variante, während Komposition die Typen nicht selbst als gemeinsames `Animal` gruppiert; die Beispiele sind kurz und kein systematischer Vergleich größerer Programme.
Mittel
Der Artikel vergleicht drei Rust-Muster, die der Autor als Alternativen zur klassischen Klassenvererbung erläutert. Am Beispiel von Katzen und Hunden zeigt er, wie sich gemeinsames Verhalten oder gemeinsame Daten abbilden lassen.
Mit einem `enum Animal` werden `Cat` und `Dog` als Varianten gebündelt. Das funktioniert, verlangt beim Übergeben an eine gemeinsame Funktion aber das explizite Verpacken in die passende Enum-Variante. Ein `Animal`-Trait lässt beide Typen dieselbe Methode implementieren; eine Funktion kann sie über `&dyn Animal` entgegennehmen. Der Autor hält das für eine sauberere, eher Rust-typische Lösung, wenn Verhalten geteilt werden soll.
Für gemeinsame Eigenschaften wie einen Namen schlägt er Komposition vor: `Cat` und `Dog` enthalten jeweils eine Basisstruktur `Animal` mit Name und Zugriffsmethode. Das kann laut Artikel wiederholte Arbeit bei mehreren gemeinsamen Feldern verringern. Anders als Enum und Trait fasst dieser Ansatz die beiden Typen jedoch nicht selbst zu einem gemeinsamen `Animal`-Argument zusammen; eine gemeinsame Funktion muss das eingebettete Feld erhalten.
Der Beitrag demonstriert die Ansätze anhand kurzer Codebeispiele, ohne sie in größeren Programmen systematisch zu vergleichen. Die Wahl soll davon abhängen, ob Varianten, Verhalten oder Daten gemeinsam genutzt werden.
Ausführlich lesen
Der Artikel „Rust: Implement Inheritance 3 Ways“ stellt drei Möglichkeiten vor, in Rust Verhaltensweisen oder gemeinsame Daten zwischen Typen zu organisieren: `enum`, `trait` und Strukturkomposition. Der Autor grenzt das Thema von der Debatte ab, ob Rust objektorientiert sei. Er weist darauf hin, dass Rust keine Klassenvererbung wie Python, Java oder Swift bietet, und verwendet „Vererbung“ hier als praktische Analogie für unterschiedliche Formen gemeinsamer Funktionen und Eigenschaften.
Als durchgängiges Beispiel dienen Katzen und Hunde, die Geräusche erzeugen. Beim ersten Ansatz ist `Animal` ein `enum` mit den Varianten `Cat(Cat)` und `Dog(Dog)`. Die einzelnen Typen implementieren jeweils `get_noise`; `Animal` leitet den Aufruf über ein `match` an den passenden Typ weiter. Eine Funktion kann dann ein `Animal` entgegennehmen und das Geräusch ausgeben. Laut Artikel funktioniert das, erfordert beim Erzeugen des Funktionsarguments aber wiederholt die ausdrückliche Verpackung in `Animal::Cat` oder `Animal::Dog` und wirkt deshalb weniger elegant.
Der zweite Ansatz ersetzt das Enum durch ein `Animal`-Trait mit der Methode `get_noise`. `Cat` und `Dog` implementieren das Trait jeweils selbst. Eine gemeinsame Funktion nimmt eine dynamische Trait-Referenz (`&dyn Animal`) entgegen, sodass beide Typen direkt übergeben werden können. Der Autor bewertet diese Variante als sauberer und als eher idiomatisch für Rust. Er empfiehlt sie, wenn die Typen gemeinsames Verhalten bereitstellen sollen und die Enum-Lösung ausreicht, als möglichen Anlass, stattdessen ein Trait zu verwenden.
Der dritte Ansatz behandelt gemeinsame Eigenschaften, etwa einen Namen. Dafür erhält `Animal` ein Feld `name` und eine Methode `get_name`; `Cat` und `Dog` enthalten jeweils ein `Animal`-Feld und stellen Konstruktoren sowie eigene `name`-Methoden bereit, die auf den eingebetteten Wert zugreifen. Der Autor zufolge kann dies Arbeit beim Schreiben und Warten verringern, wenn mehrere gemeinsame Parameter hinzukommen. Zugleich gibt es eine wesentliche Grenze: Zusammensetzung erlaubt nicht, `Cat` und `Dog` gemeinsam als `Animal` zu gruppieren, wie es bei Enum und Trait möglich ist. Für eine gemeinsame Funktion wie `print_name` muss das eingebettete `Animal` daher erst aus dem jeweiligen Typ herausgenommen und als Argument übergeben werden.
Das Vorgehen des Beitrags ist eine Folge kurzer Codebeispiele mit demselben Tier-Szenario; eine systematische Messung oder ein Vergleich anhand größerer Programme wird nicht berichtet. Das Ergebnis ist eine Auswahlhilfe, keine allgemeingültige Rangfolge: Enums bündeln bekannte Varianten, Traits beschreiben gemeinsames Verhalten, und Komposition teilt gemeinsame Daten und deren Funktionen. Welche Lösung passt, hängt laut Schlussfolgerung davon ab, was im konkreten Fall gemeinsam genutzt werden soll.
Gegengeprüft von Claude Haiku 5.5: kleine Mängel
Es wurden keine Fragen angegeben; daher ist die Einordnung leer. Beide Zusammenfassungen von Luna geben den Artikel im Kern treu wieder, enthalten aber eine nicht belegte Scope-Einschätzung und lassen einzelne Punkte aus.
Im Bericht, aber nicht in der Zusammenfassung
- Der Autor hält den Trait-Ansatz ausdrücklich für den Rust-Weg (nur die mittlere Fassung erwähnt, dass er sauberer ist).
- Der Bericht stellt klar, dass Rust zwar Objekte (struct, enum) hat, aber keine Klassenvererbung; die Frage, ob Rust objektorientiert ist, wird ausdrücklich ausgeklammert.
- Die kurze Fassung lässt weg, dass der Autor die Enum-Lösung als wenig elegant beschreibt (wiederholtes Schreiben von Animal::).
In der Zusammenfassung, laut Prüfung nicht im Bericht belegt
- Die Angabe, die Beispiele seien kein systematischer Vergleich größerer Programme, ist eine Einschätzung Lunas und steht so nicht im Bericht; der Artikel sagt dazu nichts.
Wie die Modelle den Bericht einordnen
Ansicht
Filter
Kein Modell sieht bei diesem Bericht einen Bezug zu einer der 44 Sammelfragen.