Generics und Funktionen

Generics (generische Typen) ermöglichen es Ihnen, flexiblen und wiederverwendbaren Code zu schreiben und die Duplizierung von Logik für verschiedene Datentypen zu vermeiden. Anstatt mehrere Funktionen oder Strukturen für verschiedene Typen (wie i32, f64 oder String) zu definieren, können wir einen generischen Typparameter verwenden, der konventionell mit dem Buchstaben T bezeichnet wird.

Der Rust-Compiler verarbeitet Generics durch einen Prozess namens Monomorphisierung: Während der Kompilierung generiert der Compiler eine Kopie des generischen Codes für jeden konkreten Typ, mit dem er tatsächlich verwendet wird. Auf diese Weise entsteht zur Laufzeit kein Leistungs-Overhead.

Generische Funktionen

Um eine generische Funktion zu definieren, setzen wir den Typparameter <T> direkt nach dem Funktionsnamen und vor der Parameterliste ein:

fn print_value<T: std::fmt::Debug>(value: T) {
    println!("Valore: {:?}", value);
}

In generischen Funktionen können wir den generischen Typ T sowohl für die Argumenttypen als auch für den Rückgabetyp verwenden:

fn identity<T>(value: T) -> T {
    value
}

Generische Strukturen

Wir können generische Typparameter auch innerhalb von Datenstrukturen (struct) verwenden, um flexible Felder zu definieren:

struct KeyValuePair<K, V> {
    key: K,
    value: V,
}

fn main() {
    let pair = KeyValuePair {
        key: String::from("eta"),
        value: 30,
    };
}

Im impl-Block für eine generische Struct müssen wir den Typparameter <T> direkt nach dem Schlüsselwort impl deklarieren, um anzuzeigen, dass wir Methoden für eine generische Struktur implementieren:

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Self {
        Container { value }
    }

    fn value(&self) -> &T {
        &self.value
    }
}

Probiere es aus

Übung 1: Die Struktur Point

Übung 2: Vertauschen eines Tupels mit swap

Übung 3: Die Struktur Container