Learn Rust Coding · Lektion

Generische Structs und Enums

Erstellen Sie flexible Datentypen.

Generische Structs und Enums ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Generische Datenstrukturen

Genau wie Funktionen können auch Structs und Enums über einen oder mehrere Typen generisch sein. So kann eine einzige Definition Werte beliebiger Typen enthalten.

Die Standardbibliothek ist auf diese Weise aufgebaut: Vec<T>, Option<T> und Result<T, E> sind allesamt generisch.

Ein generisches Struct

Deklarieren Sie den Typparameter hinter dem Namen des Structs und verwenden Sie ihn anschließend für die Felder. Hier speichert Point zwei Werte desselben Typs T.

Eine einzige Definition funktioniert nun für Punkte mit Ganzzahlen, Gleitkommazahlen und weitere Typen.

struct Point<T> {
    x: T,
    y: T,
}

Generische Structs erzeugen

Beim Erzeugen einer Instanz leitet der Compiler T aus den Feldwerten ab. Beide Felder müssen denselben Typ haben.

Dieses Programm erstellt aus demselben Struct einen Punkt mit Ganzzahlen und einen Punkt mit Gleitkommazahlen.

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 1.5, y: 4.0 };
    println!("{} {}", a.x, b.y);
}

Gemischte Typparameter

Mit zwei Parametern können sich die Feldtypen unterscheiden. Pair<T, U> kann gleichzeitig eine Ganzzahl und eine Zeichenkette enthalten.

Verwenden Sie einen Parameter, wenn die Felder denselben Typ haben müssen, und mehrere, wenn sie unterschiedliche Typen haben dürfen.

struct Pair<T, U> {
    first: T,
    second: U,
}

Methoden für generische Structs

Um Methoden hinzuzufügen, wiederholen Sie den Typparameter im impl-Block: impl<T> Point<T>. Der Parameter nach impl deklariert ihn; nach dem Typnamen wird er angewendet.

Hier gibt ein Getter eine Referenz auf das Feld x zurück.

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

Methoden mit Einschränkungen

Sie können Methoden nur für bestimmte konkrete Typen oder für Typen schreiben, die eine Einschränkung erfüllen. Dieses impl gilt ausschließlich für Point<f64>.

Daher existiert dist_from_origin für Punkte mit Gleitkommazahlen, nicht aber für Punkte mit Ganzzahlen.

struct Point<T> { x: T, y: T }

impl Point<f64> {
    fn dist_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

Ein generisches Enum

Auch Enums können generisch sein. Jede Variante kann generische Daten enthalten. Dies entspricht dem Standardtyp Option, der entweder Some(T) oder None ist.

Wenn Sie einen eigenen Typ definieren, verstehen Sie besser, wie der Bibliothekstyp funktioniert.

enum Maybe<T> {
    Just(T),
    Nothing,
}

Zwei Parameter in einem Enum

Result verwendet zwei Parameter, damit sich Erfolgs- und Fehlerwerte unterscheiden können. Hier sehen Sie eine vereinfachte Version.

Mehrere Typparameter in Enums ermöglichen eine flexible Fehlerbehandlung im gesamten Ökosystem.

enum Either<L, R> {
    Left(L),
    Right(R),
}

Generische Enums matchen

Sie führen Pattern Matching auf generischen Enums genauso aus wie auf konkreten Enums. Die Nutzlast der Variante wird innerhalb des Arms an eine Variable gebunden.

Dieses Programm entpackt ein eigenes Maybe und gibt den enthaltenen Wert oder einen Ersatzwert aus.

enum Maybe<T> { Just(T), Nothing }

fn main() {
    let m: Maybe<i32> = Maybe::Just(5);
    match m {
        Maybe::Just(n) => println!("got {}", n),
        Maybe::Nothing => println!("empty"),
    }
}

Einen Wert verpacken

Ein häufiges Muster ist ein Wrapper-Struct mit einem Feld vom Typ T und zusätzlichen Hilfsmethoden. Hier speichert Wrapper einen beliebigen Wert und gibt ihn zurück.

Dies bildet die Grundlage für Newtype-Muster und Smart-Pointer-ähnliche Typen.

struct Wrapper<T> { inner: T }

impl<T> Wrapper<T> {
    fn new(v: T) -> Self {
        Wrapper { inner: v }
    }
}

fn main() {
    let w = Wrapper::new("hi");
    println!("{}", w.inner);
}

Kein Laufzeit-Overhead

Auch generische Structs und Enums werden monomorphisiert. Point<i32> und Point<f64> werden nach der Kompilierung zu zwei unterschiedlichen, vollständig spezialisierten Typen.

Es gibt weder eine verborgene Indirektion noch ein Tag für den generischen Typ selbst.

Kurztest

Testen Sie Ihr Verständnis generischer Structs und Enums.

Zusammenfassung

Structs und Enums deklarieren Typparameter hinter ihrem Namen und verwenden sie in Feldern und Varianten. Dadurch entstehen wiederverwendbare Container wie Option und Result.

Methoden wiederholen die Parameter in impl<T>, und Sie können spezialisierte impl-Blöcke für konkrete Typen schreiben. Alles wird für einen Overhead von null monomorphisiert.

Häufig gestellte Fragen

Ist die Lektion „Generische Structs und Enums“ kostenlos?

Ja — der vollständige Text von „Generische Structs und Enums“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Generische Structs und Enums“?

Erstellen Sie flexible Datentypen. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Generische Structs und Enums“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding