Generische Datentypen

Wir verwenden generische Datentypen (generics), um Definitionen für Elemente wie Funktionssignaturen oder Strukturen (structs) zu erstellen, die wir dann mit vielen verschiedenen konkreten Datentypen verwenden können. Sehen wir uns zunächst an, wie Funktionen, Strukturen, Aufzählungen und Methoden mithilfe von generischen Datentypen definiert werden können. Danach werden wir uns ansehen, wie generische Datentypen die Code-Performanz beeinflussen.

In Funktionsdefinitionen

Bei der Definition einer Funktion, die generische Datentypen verwendet, platzieren wir die generischen Datentypen in der Signatur der Funktion, wo wir normalerweise die Datentypen der Parameter und des Rückgabewerts angeben würden. Dadurch wird unser Code flexibler und bietet den Aufrufern unserer Funktion mehr Funktionalität, während gleichzeitig Code-Duplikate verhindert werden.

Um mit unserer Funktion largest fortzufahren, zeigt Codeblock 10-4 zwei Funktionen, die beide den größten Wert in einem Anteilstyp finden. Wir werden diese dann in einer einzigen Funktion kombinieren, die generische Typen verwendet.

Dateiname: src/main.rs

fn largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> char {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("Die größte Zahl ist {}", result);
    assert_eq!(result, 100);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("Das größte Zeichen ist {}", result);
    assert_eq!(result, 'y');
}

Codeblock 10-4: Zwei Funktionen, die sich nur in ihren Namen und den Typen in ihren Signaturen unterscheiden

Die Funktion largest_i32 ist diejenige, die wir in Codeblock 10-3 extrahiert haben und die den größten i32 in einem Anteilstyp findet. Die Funktion largest_char findet das größte char in einem Anteilstyp. Die Funktionsrümpfe haben den gleichen Code, also lass uns die Duplizierung eliminieren, indem wir einen generischen Typparameter in einer einzigen Funktion einführen.

Um die Typen in einer neuen, einzigen Funktion zu parametrisieren, müssen wir den Typparameter benennen, so wie wir es für die Wertparameter einer Funktion tun. Du kannst jeden beliebigen Bezeichner als Typparametername verwenden. Aber wir werden T verwenden, weil die Typparameternamen gemäß Konvention in Rust kurz sind, oft nur ein Buchstabe, und Rusts Typbezeichnungskonvention verwendet Binnenmajuskel (UpperCamelCase). Als Abkürzung für „Typ“ ist T die Standardwahl der meisten Rust-Programmierer.

Wenn wir einen Parameter im Funktionsrumpf verwenden, müssen wir den Parameternamen in der Signatur deklarieren, damit der Compiler weiß, was dieser Name bedeutet. In ähnlicher Weise müssen wir den Typ-Parameternamen deklarieren, bevor wir ihn in einer Funktionssignatur verwenden können. Um die generische Funktion largest zu definieren, platzieren wir die Typnamen-Deklarationen innerhalb spitzer Klammern <>, zwischen dem Funktionsnamen und der Parameterliste, so wie hier:

fn largest<T>(list: &[T]) -> &T {

Wir lesen diese Definition wie folgt: Die Funktion largest ist generisch über einen Typ T. Sie hat einen Parameter namens list, der ein Anteilstyp von Werten des Typs T ist. Die Funktion largest gibt eine Referenz auf denn Wert des gleichen Typs T zurück.

Codeblock 10-5 zeigt die kombinierte Funktionsdefinition largest, die den generischen Datentyp in ihrer Signatur verwendet. Der Codeblock zeigt auch, wie wir die Funktion entweder mit einem Anteilstyp von i32-Werten oder char-Werten aufrufen können. Beachte, dass sich dieser Code noch nicht kompilieren lässt, aber wir werden das Problem später in diesem Kapitel beheben.

Dateiname: src/main.rs

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("Die größte Zahl ist {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("Das größte Zeichen ist {}", result);
}

Codeblock 10-5: Die Funktion largest mit generischen Typparametern; diese kompiliert aber noch nicht

Wenn wir diesen Code kompilieren, erhalten wir diesen Fehler:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- &T
  |            |
  |            &T
  |
help: consider restricting type parameter `T`
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
  |             ++++++++++++++++++++++

For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Der Hilfetext erwähnt std::cmp::PartialOrd, was ein Merkmal (trait) ist, und wir werden im nächsten Abschnitt über Merkmale sprechen. Vorerst bedeutet dieser Fehler, dass der Rumpf von largest nicht für alle möglichen Typen funktioniert, die T sein könnten. Da wir Werte des Typs T im Rumpf vergleichen wollen, können wir nur Typen verwenden, deren Werte sortiert werden können. Um Vergleiche zu ermöglichen, hat die Standardbibliothek das Merkmal std::cmp::PartialOrd, das du auf Typen implementieren kannst (siehe Anhang C für weitere Informationen zu diesem Merkmal). Indem wir dem Vorschlag des Hilfetextes folgen, schränken wir die für T gültigen Typen auf diejenigen ein, die PartialOrd implementieren und dieses Beispiel kompiliert, weil die Standardbibliothek PartialOrd sowohl auf i32 als auch auf char implementiert.

In Struktur-Definitionen

Wir können auch Strukturen definieren, um einen generischen Typparameter in einem oder mehreren Feldern mit der <> Syntax zu verwenden. Codeblock 10-6 definiert eine Struktur Point<T>, um Koordinatenwerte x und y eines beliebigen Typs aufzunehmen.

Dateiname: src/main.rs

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

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

Codeblock 10-6: Eine Struktur Point<T>, die Werte x und y vom Typ T enthält

Die Syntax zum Verwenden von generischen Datentypen in Strukturdefinitionen ähnelt der Syntax, die in Funktionsdefinitionen verwendet wird. Zuerst deklarieren wir den Namen des Typparameters innerhalb spitzer Klammern direkt nach dem Namen der Struktur. Dann verwenden wir den generischen Typ in der Strukturdefinition, wo wir sonst konkrete Datentypen angeben würden.

Beachte, da wir nur einen generischen Typ zur Definition von Point<T> verwendet haben, besagt diese Definition, dass die Struktur Point<T> generisch über einen Typ T ist, und die beiden Felder x und y denselben Typ haben, welcher Typ das auch immer sein mag. Wenn wir eine Instanz von Point<T> erzeugen, die Werte unterschiedlichen Typs hat, wie in Codeblock 10-7, wird sich unser Code nicht kompilieren lassen.

Dateiname: src/main.rs

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

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

Codeblock 10-7: Die Felder x und y müssen vom gleichen Typ sein, da beide den gleichen generischen Datentyp T haben.

Wenn wir in diesem Beispiel x den Integer-Wert 5 zuweisen, lassen wir den Compiler wissen, dass der generische Typ T für diese Instanz von Point<T> ein Integer sein wird. Wenn wir dann 4.0 für y angeben, das wir so definiert haben, dass es den gleichen Typ wie x hat, erhalten wir einen Typfehler wie diesen:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
 --> src/main.rs:7:38
  |
7 |     let wont_work = Point { x: 5, y: 4.0 };
  |                                      ^^^ expected integer, found floating-point number

For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Um eine Struktur Point zu definieren, bei der x und y generische, aber unterschiedliche, Typen haben können, können wir mehrere generische Typparameter verwenden. Zum Beispiel ändern wir in Codeblock 10-8 die Definition von Point so, dass sie über den Typen T und U generisch ist, wobei x vom Typ T und y vom Typ U ist.

Dateiname: src/main.rs

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

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

Codeblock 10-8: Point<T, U> ist generisch über zwei Typen, sodass x und y Werte unterschiedlichen Typs haben können

Jetzt sind alle gezeigten Instanzen von Point erlaubt! Du kannst so viele generische Typparameter in einer Definition verwenden, wie du willst, aber das Verwenden von mehr als einigen wenigen macht deinen Code schwer lesbar. Wenn du denkst, dass du in deinem Code viele generische Typen benötigst, könnte dies darauf hinweisen, dass dein Code in kleinere Teile zerlegt werden muss.

In Aufzählungsdefinitionen

Wie wir es bei Strukturen gemacht haben, können wir Aufzählungen definieren, um generische Datentypen in ihren Varianten zu verwenden. Werfen wir noch einmal einen Blick auf die Aufzählung Option<T>, die die Standardbibliothek bietet und die wir in Kapitel 6 verwendet haben:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

Diese Definition dürfte für dich jetzt mehr Sinn machen. Wie du sehen kannst, ist die Aufzählung Option<T> über dem Typ T generisch und hat zwei Varianten: Some, die einen Wert vom Typ T enthält, und None, die keinen Wert enthält. Durch das Verwenden der Aufzählung Option<T> können wir das abstrakte Konzept eines optionalen Wertes ausdrücken und da Option<T> generisch ist, können wir diese Abstraktion unabhängig vom Typ des optionalen Wertes verwenden.

Aufzählungen können auch mehrere generische Typen verwenden. Die Definition der Aufzählung Result, die wir in Kapitel 9 verwendet haben, ist ein Beispiel dafür:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Die Aufzählung Result ist generisch über zwei Typen T und E und hat zwei Varianten: Ok, die einen Wert vom Typ T enthält, und Err, die einen Wert vom Typ E enthält. Diese Definition macht es bequem, die Aufzählung Result überall dort zu verwenden, wo wir eine Operation haben, die erfolgreich sein (gibt einen Wert vom Typ T zurück) oder fehlschlagen (gibt einen Fehler vom Typ E zurück) könnte. Tatsächlich haben wir dies beim Öffnen einer Datei in Codeblock 9-3 verwendet, wobei für T der Typ std::fs::File verwendet wurde, wenn die Datei erfolgreich geöffnet wurde, und für E der Typ std::io::Error, wenn es Probleme beim Öffnen der Datei gab.

Wenn du in deinem Code Situationen mit mehreren Struktur- oder Aufzählungsdefinitionen erkennst, die sich nur in den Typen der darin enthaltenen Werte unterscheiden, kannst du doppelten Code vermeiden, indem du stattdessen generische Typen verwendest.

In Methodendefinitionen

Wir können Methoden auf Strukturen und Aufzählungen implementieren (wie wir es in Kapitel 5 getan haben) und auch generische Typen in ihren Definitionen verwenden. Codeblock 10-9 zeigt die Struktur Point<T>, die wir in Codeblock 10-6 definiert haben, mit einer darauf implementierten Methode namens x.

Dateiname: src/main.rs

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

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

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Codeblock 10-9: Implementierung einer Methode x auf der Struktur Point<T>, die eine Referenz auf das Feld x vom Typ T zurückgibt

Hier haben wir eine Methode x auf Point<T> definiert, die eine Referenz auf den Wert im Feld x zurückgibt.

Beachte, dass wir T direkt nach impl deklarieren müssen, damit wir Methoden zum Typ Point<T> implementieren können. Durch das Deklarieren von T als generischen Typ hinter impl kann Rust erkennen, dass der Typ in spitzen Klammern in Point ein generischer und kein konkreter Typ ist. Wir hätten einen anderen Namen für den generischen Parameter wählen können als den in der Strukturdefinition deklarierten generischen Parameter, aber die Verwendung desselben Namens ist üblich. Methoden, die innerhalb eines impl geschrieben werden, das den generischen Typ deklariert, werden auf jeder Instanz des Typs definiert, unabhängig davon, welcher konkrete Typ am Ende den generischen Typ ersetzt.

Wir können auch Einschränkungen für generische Typen angeben, wenn wir Methoden auf dem Typ definieren. Wir könnten zum Beispiel Methoden nur auf Point<f32>-Instanzen implementieren und nicht auf Point<T>-Instanzen mit einem beliebigen generischen Typ. In Codeblock 10-10 verwenden wir den konkreten Typ f32, d.h. wir deklarieren keinen Typ hinter impl.

Dateiname: src/main.rs

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

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

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Codeblock 10-10: Ein impl-Block, der nur für eine Struktur mit einem bestimmten konkreten Typ für den generischen Typparameter T gilt

Dieser Code bedeutet, dass der Typ Point<f32> eine Methode distance_from_origin hat und andere Instanzen von Point<T>, bei denen T nicht vom Typ f32 ist, haben diese Methode nicht. Die Methode misst, wie weit unser Punkt vom Punkt mit den Koordinaten (0,0, 0,0) entfernt ist, und verwendet mathematische Operationen, die nur für Fließkomma-Typen zur Verfügung stehen.

Generische Typparameter in einer Strukturdefinition sind nicht immer die gleichen wie die, die du in denselben Methodensignaturen für diese Struktur verwendest. In Codeblock 10-11 werden die generischen Typen X1 und Y1 für die Struktur Point und X2 und Y2 für die Signatur der Methode mixup verwendet, um das Beispiel zu verdeutlichen. Die Methode erzeugt eine neue Point-Instanz mit dem Wert x aus self (vom Typ X1) und dem Wert y aus dem übergebenen Point (vom Typ Y2).

Dateiname: src/main.rs

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hallo", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

Codeblock 10-11: Eine Methode, die generische Typen aus der Definition ihrer Struktur anders verwendet

In main haben wir einen Point definiert, bei dem x den Typ i32 (mit dem Wert 5) und y den Typ f64 (mit dem Wert 10.4) hat. Die Variable p2 ist eine Struktur Point, bei der x einen Zeichenkettenanteilstyp (mit dem Wert "Hallo") und y den Typ char (mit dem Wert c) hat. Wenn wir mixup auf p1 mit dem Argument p2 aufrufen, erhalten wir p3, das ein i32 für x haben wird, weil x von p1 kam. Die Variable p3 wird ein char für y haben, weil y von p2 stammt. Der Makroaufruf println! gibt p3.x = 5, p3.y = c aus.

Der Zweck dieses Beispiels ist es, eine Situation zu demonstrieren, in der einige generische Parameter mit impl und einige mit der Methodendefinition deklariert werden. Hier werden die generischen Parameter X1 und Y1 nach impl deklariert, weil sie zur Strukturdefinition gehören. Die generischen Parameter X2 und Y2 werden nach fn mixup deklariert, da sie nur für die Methode relevant sind.

Code-Performanz beim Verwenden generischer Datentypen

Du fragst dich vielleicht, ob beim Verwenden generischer Typparameter Laufzeitkosten anfallen. Die gute Nachricht ist, dass die Verwendung generischer Typen die Ausführung deines Programms nicht langsamer macht als bei konkreten Typen.

Rust erreicht dies durch Duplizierung von Code mit generischen Datentypen zur Kompilierzeit. Codeduplizierung (monomorphization) ist der Vorgang der Umwandlung von generischem Code in spezifischen Code durch Ausfüllen der konkreten Typen, die bei der Kompilierung verwendet werden. Bei diesem Vorgang führt der Compiler das Gegenteil der Schritte aus, die wir beim Erstellen der generischen Funktion in Codeblock 10-5 angewendet haben: Der Compiler schaut sich alle Stellen an, an denen generischer Code aufgerufen wird, und generiert Code für die konkreten Typen, mit denen der generische Code aufgerufen wird.

Betrachten wir die Funktionsweise bei der Aufzählung Option<T> der Standardbibliothek:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

Wenn Rust diesen Code kompiliert, führt es eine Codeduplizierung durch. Während dieses Vorgangs liest der Compiler die Werte ein, die in Option<T>-Instanzen verwendet wurden, und identifiziert zwei Arten von Option<T>: Eine verwendet den Typ i32 und die andere f64. Als solches erweitert es die allgemeine Definition von Option<T> in zwei auf i32 und f64 spezialisierte Definitionen, wodurch die allgemeine Definition durch die spezifische ersetzt wird.

Die duplizierte Codeversion sieht ähnlich aus wie die folgende (der Compiler verwendet andere Namen als die, die wir hier zur Veranschaulichung verwenden):

Dateiname: src/main.rs

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

Der generische Typ Option<T> wird durch die vom Compiler erstellten spezifischen Definitionen ersetzt. Da Rust generischen Code in Code kompiliert, der den Typ in jedem Fall spezifiziert, zahlen wir keine Laufzeitkosten beim Verwenden von generischen Datentypen. Wenn der Code läuft, verhält er sich genauso, wie wenn wir jede Definition von Hand dupliziert hätten. Der Vorgang der Codeduplizierung macht Rusts generische Datentypen zur Laufzeit äußerst effizient.