Rust Lebensdauer und Trait-Begrenzungen

Einführung

In diesem Lab lernen wir über die Begrenzungen in Rust, die verwendet werden, um die Lebensdauern oder Traits von generischen Typen einzuschränken. Das Zeichen : wird verwendet, um anzuzeigen, dass alle Referenzen in einem Typ eine bestimmte Lebensdauer überdauern müssen, während + verwendet wird, um anzuzeigen, dass ein Typ ein bestimmtes Trait implementieren muss und alle darin enthaltenen Referenzen eine bestimmte Lebensdauer überdauern müssen. Ein Beispielcodeausschnitt zeigt die Syntax und Verwendung von Begrenzungen in Rust.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Skills Graph

Begrenzungen

Genau wie generische Typen begrenzt werden können, verwenden auch Lebensdauern (selbst generisch) Begrenzungen. Das Zeichen : hat hier eine etwas andere Bedeutung, aber + ist das gleiche. Beachten Sie, wie die folgenden Lesarten lauten:

1. T: 'a: Alle Referenzen in T müssen die Lebensdauer 'a überdauern.
2. T: Trait + 'a: Der Typ T muss das Trait Trait implementieren und alle Referenzen in T müssen 'a überdauern.

Das folgende Beispiel zeigt die obige Syntax im Einsatz, die nach dem Schlüsselwort where verwendet wird:

use std::fmt::Debug; // Trait, mit dem begrenzend gearbeitet wird.

#[derive(Debug)]
struct Ref<'a, T: 'a>(&'a T);
// `Ref` enthält eine Referenz auf einen generischen Typ `T`, der
// eine unbekannte Lebensdauer `'a` hat. `T` ist so begrenzt, dass alle
// *Referenzen* in `T` die Lebensdauer `'a` überdauern müssen. Darüber hinaus
// darf die Lebensdauer von `Ref` nicht die Lebensdauer `'a` überschreiten.

// Eine generische Funktion, die mit dem `Debug`-Trait ausgibt.
fn print<T>(t: T) where
    T: Debug {
    println!("`print`: t ist {:?}", t);
}

// Hier wird eine Referenz auf `T` genommen, wobei `T`
// das `Debug`-Trait implementiert und alle *Referenzen* in `T`
// die Lebensdauer `'a` überdauern. Darüber hinaus muss
// die Lebensdauer `'a` die Lebensdauer der Funktion überdauern.
fn print_ref<'a, T>(t: &'a T) where
    T: Debug + 'a {
    println!("`print_ref`: t ist {:?}", t);
}

fn main() {
    let x = 7;
    let ref_x = Ref(&x);

    print_ref(&ref_x);
    print(ref_x);
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu den Begrenzungen abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.