Eigentum und Moves

Einführung

In diesem Lab wird erklärt, dass in Rust Variablen die Eigentumsgewalt an Ressourcen haben und nur einen Besitzer haben können, was verhindert, dass Ressourcen mehrfach freigegeben werden. Wenn Variablen zugewiesen werden oder Funktionsargumente per Wert übergeben werden, wird die Eigentumsgewalt an die Ressourcen übertragen, was als Move bezeichnet wird. Nach dem Move kann der vorherige Besitzer nicht mehr verwendet werden, um das Erstellen von fehlerhaften Zeigern zu vermeiden. Das Codebeispiel demonstriert diese Konzepte, indem gezeigt wird, wie die Eigentumsgewalt von auf dem Stack und auf dem Heap zugewiesenen Variablen übertragen wird und wie das Zugreifen auf eine Variable nach Übertragung ihrer Eigentumsgewalt zu Fehlern führt.

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.

Eigentum und Moves

Da Variablen sich um das Freigeben ihrer eigenen Ressourcen kümmern, kann eine Ressource nur einen Besitzer haben. Dadurch wird auch vermieden, dass Ressourcen mehrfach freigegeben werden. Beachten Sie, dass nicht alle Variablen Ressourcen besitzen (z.B. [Referenzen]).

Wenn Sie Zuweisungen durchführen (let x = y) oder Funktionsargumente per Wert übergeben (foo(x)), wird die Eigentumsgewalt an die Ressourcen übertragen. In Rust-Sprache wird dies als Move bezeichnet.

Nachdem die Ressourcen bewegt wurden, kann der vorherige Besitzer nicht mehr verwendet werden. Dadurch wird vermieden, dass fehlerhafte Zeiger erstellt werden.

// Diese Funktion erhält die Eigentumsgewalt an den auf dem Heap zugewiesenen Speicher
fn destroy_box(c: Box<i32>) {
    println!("Zerstöre eine Box, die enthält {}", c);

    // `c` wird zerstört und der Speicher freigegeben
}

fn main() {
    // _Stack_-zugewiesene Ganzzahl
    let x = 5u32;

    // *Kopiere* `x` in `y` - keine Ressourcen werden bewegt
    let y = x;

    // Beide Werte können unabhängig voneinander verwendet werden
    println!("x ist {}, und y ist {}", x, y);

    // `a` ist ein Zeiger auf eine _Heap_-zugewiesene Ganzzahl
    let a = Box::new(5i32);

    println!("a enthält: {}", a);

    // *Bewege* `a` in `b`
    let b = a;
    // Die Zeigeradresse von `a` wird in `b` kopiert (nicht die Daten).
    // Beide sind jetzt Zeiger auf die gleiche auf dem Heap zugewiesene Daten, aber
    // `b` besitzt sie jetzt.

    // Fehler! `a` kann die Daten nicht mehr zugreifen, da es die
    // Heap-Speicher nicht mehr besitzt
    //println!("a enthält: {}", a);
    // TODO ^ Versuchen Sie, diese Zeile auszulassen

    // Diese Funktion erhält die Eigentumsgewalt an den auf dem Heap zugewiesenen Speicher von `b`
    destroy_box(b);

    // Da der Heap-Speicher zu diesem Zeitpunkt bereits freigegeben wurde, würde diese Aktion
    // dazu führen, auf freien Speicher zu verweisen, was jedoch vom Compiler verboten ist
    // Fehler! Aus dem gleichen Grund wie der vorherige Fehler
    //println!("b enthält: {}", b);
    // TODO ^ Versuchen Sie, diese Zeile auszulassen
}

Zusammenfassung

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