Lebenszeitkonzepte in der Rust-Programmierung

Einführung

In diesem Lab werden wir das Konzept der Lebenszeiten in Rust untersuchen und wie der Compiler diese verwendet, um die Gültigkeit von Entleihen im Code sicherzustellen. Lebenszeiten sind ein Konstrukt des Compilers, das die Lebensdauer einer Variable von ihrer Erstellung bis zu ihrer Zerstörung bestimmt. Während Lebenszeiten und Gültigkeitsbereiche verwandt sind, sind sie nicht identisch. Wenn eine Variable mit dem &-Operator entliehen wird, hat das Entlehen eine Lebenszeit, die durch seine Deklaration bestimmt wird, und es ist gültig, solange es vor dem Zerstören des Verleiher endet. Der Gültigkeitsbereich des Entlehens wird jedoch durch den Ort bestimmt, an dem die Referenz verwendet wird. Der bereitgestellte Beispielcode zeigt, wie Lebenszeiten und Gültigkeitsbereiche in der Praxis verwendet werden, wobei jede Variable ihre eigene Lebenszeit und ihren eigenen Gültigkeitsbereich hat.

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

Lebenszeiten

Eine Lebenszeit ist ein Konstrukt des Compilers (oder genauer gesagt, seiner Entleihprüfung) und wird verwendet, um sicherzustellen, dass alle Entleihungen gültig sind. Genauer gesagt beginnt die Lebenszeit einer Variable bei ihrer Erstellung und endet bei ihrer Zerstörung. Obwohl Lebenszeiten und Gültigkeitsbereiche oft zusammen erwähnt werden, sind sie nicht identisch.

Nehmen wir beispielsweise den Fall, in dem wir eine Variable via & entleihen. Die Entleihung hat eine Lebenszeit, die durch ihren Deklarationsort bestimmt wird. Folglich ist die Entleihung gültig, solange sie vor dem Zerstören des Verleiher endet. Der Gültigkeitsbereich der Entleihung wird jedoch durch den Ort bestimmt, an dem die Referenz verwendet wird.

Im folgenden Beispiel und im Rest dieses Abschnitts werden wir sehen, wie Lebenszeiten mit Gültigkeitsbereichen zusammenhängen und wie sich die beiden unterscheiden.

// Lebenszeiten werden unten mit Linien annotiert, die das Erstellen
// und Zerstören jeder Variable anzeigen.
// `i` hat die längste Lebenszeit, da ihr Gültigkeitsbereich vollständig
// beide `Entleihungen1` und `Entleihungen2` umschließt. Die Lebensdauer von
// `Entleihungen1` im Vergleich zu `Entleihungen2` ist unerheblich, da sie disjunkt sind.
fn main() {
    let i = 3; // Lebenszeit für `i` beginnt. ────────────────┐
    //                                                     │
    { //                                                   │
        let borrow1 = &i; // `Entleihungen1` Lebenszeit beginnt. ──┐│
        //                                                ││
        println!("Entleihungen1: {}", borrow1); //              ││
    } // `Entleihungen1` endet. ─────────────────────────────────┘│
    //                                                     │
    //                                                     │
    { //                                                   │
        let borrow2 = &i; // `Entleihungen2` Lebenszeit beginnt. ──┐│
        //                                                ││
        println!("Entleihungen2: {}", borrow2); //              ││
    } // `Entleihungen2` endet. ─────────────────────────────────┘│
    //                                                     │
}   // Lebenszeit endet. ─────────────────────────────────────┘

Beachten Sie, dass keine Namen oder Typen den Lebenszeiten zugewiesen werden. Dies begrenzt die Verwendung der Lebenszeiten, wie wir sehen werden.

Zusammenfassung

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