Rust Rust: sicher und schnell programmieren

Rust Ownership einfach erklärt: Regeln, Move und Clone

Rust Ownership sorgt dafür, dass jeder Wert genau einen Besitzer hat und automatisch aufgeräumt wird, wenn sein Gültigkeitsbereich endet. Du lernst die drei Regeln, Move-Semantik, den Unterschied zwischen Clone und Copy und den Fehler E0382 anhand lauffähiger Beispiele.

Serhat ALPASLAN14 Min. Lesezeit

Inhaltsverzeichnis

Rust-Ownership (Eigentümerschaft) ist das Modell, das zur Kompilierzeit festlegt, wer der Eigentümer eines Werts im Speicher ist und wann er freigegeben wird. Diese Lektion ist für Rust 1.91 geschrieben und Teil der Reihe „Rust: Sicher und schnell programmieren“. Wir untersuchen die Ownership-Regeln, die Move-Semantik, den Unterschied zwischen clone und Copy sowie den Compilerfehler E0382 anhand lauffähiger Beispiele; der Rust Borrow Checker prüft diese Regeln zur Kompilierzeit.

Diese Lektion setzt voraus, dass du die Lektion zu Rust-Funktionen und Kontrollfluss abgeschlossen hast.

Was ist Rust-Ownership?

Kurze Antwort Rust-Ownership ist eine Regel zur Kompilierzeit, die dafür sorgt, dass jeder Wert genau einen Eigentümer hat und der Wert automatisch freigegeben wird, sobald der Eigentümer den Gültigkeitsbereich verlässt. Dadurch bietet Rust Speichersicherheit ohne Garbage Collector zur Laufzeit.

Ownership ist der zentrale Mechanismus, der Rust von anderen Systemsprachen unterscheidet: Der Compiler verfolgt, welche Variable welchen Speicherbereich verwaltet, und lehnt Regelverstöße ab, bevor das Programm überhaupt läuft. Ownership arbeitet zusammen mit Borrowing und Lifetimes; in dieser Lektion behandeln wir nur den Ownership-Teil.

In der Praxis heißt das: Der Compiler beantwortet die Frage „Bleibt dieser String bei mir, wenn ich ihn an eine Funktion übergebe?“. Ist die Antwort nein, kompiliert der Code nicht. Diese Strenge verhindert Speicherfehler wie Use-after-free, Double Free und hängende Zeiger bereits zur Kompilierzeit. Speicherlecks gelten in Rust dagegen als sicher; Ownership erschwert sie, garantiert aber nicht, dass sie ausbleiben.

Die drei Regeln der Ownership

Kurze Antwort Die Rust-Ownership-Regeln bestehen aus drei Punkten: Jeder Wert hat genau einen Eigentümer, es kann immer nur einen Eigentümer gleichzeitig geben, und wenn der Eigentümer den Gültigkeitsbereich verlässt, wird der Wert verworfen. Diese drei Regeln fassen das gesamte Ownership-Verhalten zusammen.

  1. Jeder Wert hat einen Eigentümer. Wenn ein String erzeugt wird, ist die Variable, die ihn hält, sein Eigentümer.
  2. Es kann immer nur einen Eigentümer gleichzeitig geben. Wird die Ownership an eine andere Variable übertragen, wird die alte ungültig.
  3. Verlässt der Eigentümer den Gültigkeitsbereich, wird der Wert verworfen. Wenn der Gültigkeitsbereich endet, räumt Rust den Speicher automatisch auf.

In der offiziellen Quelle werden diese Regeln in The Rust Programming Language, Kapitel 4.1 in derselben Reihenfolge genannt. Die Regeln sind kurz; schwierig ist, sie beim täglichen Programmieren zur Gewohnheit zu machen.

Stack und Heap: Warum das wichtig ist

Kurze Antwort Der Stack ist ein Speicherbereich mit fester Größe und sehr schnell, der Heap ist flexibel, aber langsamer; die Ownership-Regeln existieren vor allem, um festzulegen, wer die Daten auf dem Heap aufräumt. Daten auf dem Stack verschwinden mit dem Gültigkeitsbereich von selbst, Daten auf dem Heap brauchen einen Eigentümer.

Der Typ String ist das beste Beispiel für diese Unterscheidung: Die Variable selbst liegt mit drei Feldern (Zeiger, Länge, Kapazität) auf dem Stack, die Zeichen leben auf dem Heap. Verlässt die Variable den Gültigkeitsbereich, räumt Rust sowohl den Stack-Eintrag als auch die Heap-Allokation auf.

Eigenschaft Stack Heap
Größe Zur Kompilierzeit bekannt Wird zur Laufzeit festgelegt
Geschwindigkeit Sehr schnell, reine Zeigerbewegung Langsamer, Allokation und Suche nötig
Aufräumen Am Ende des Gültigkeitsbereichs automatisch Über den Eigentümer mit Drop
Typische Typen i32, bool, char, &str String, Vec<T>, Box<T>

Deshalb ist das Kopieren von Typen wie i32 praktisch kostenlos, während das Kopieren eines String eine neue Allokation auf dem Heap bedeutet. Das Ownership-Modell macht genau diesen Kostenunterschied sichtbar.

Move: Was passiert, wenn ein Wert verschoben wird

Kurze Antwort Rust-Move-Semantik bedeutet, dass beim Zuweisen eines Werts an eine andere Variable oder beim Übergeben an eine Funktion das Ownership übergeht und die alte Variable ungültig wird. Die Daten auf dem Heap werden nicht verschoben; nur der Stack-Eintrag, der auf sie zeigt, wird in die neue Variable kopiert.

Was auf Speicherebene passiert, Schritt für Schritt:

  1. Die Zeile let s2 = s1; kopiert das Tripel aus Zeiger, Länge und Kapazität auf dem Stack nach s2.
  2. Die Bytes von merhaba auf dem Heap werden nicht kopiert; beide Variablen zeigen auf denselben Puffer.
  3. Der Compiler markiert s1 als ungültig, sodass der Puffer am Ende des Gültigkeitsbereichs nur einmal über s2 freigegeben wird.

Ein Move ist zur Laufzeit eine günstige Bit-Kopie; der einzige Unterschied zu Copy ist, dass die Quelle ungültig wird.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1; // Move: Ownership ging auf s2 über

    println!("s2 = {}", s2);

    let x = 5;
    let y = x; // i32 ist Copy, daher wird kopiert

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

    let s3 = s2.clone(); // explizite Kopie
    println!("s3 = {}", s3);
}
s2 = merhaba
x = 5, y = 5
s3 = merhaba

Im obigen Programm wird s1 nach der Zuweisung nicht mehr verwendet, denn das Ownership von s1 ist auf s2 übergegangen. Dieselbe Zeile verhält sich für i32 anders: x bleibt gültig, weil i32 das Copy-Trait implementiert.

Den Fehler E0382 Zeile für Zeile lesen

Das folgende Fragment kompiliert nicht, weil es versucht, einen verschobenen Wert zu verwenden. Die Fehlerausgabe wurde mit rustc erzeugt und ist gekürzt.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1;

    println!("{}", s1);
}
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:20
  |
2 |     let s1 = String::from("merhaba");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |
5 |     println!("{}", s1);
  |                    ^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let s2 = s1.clone();
  |                ++++++++
  • Fehlercode: E0382 bedeutet, dass ein Wert nach dem Verschieben verwendet wird. Hier sagt die Meldung borrow of moved value, weil println! den Wert ausleiht; bei einem Ausdruck, der direkt verschiebt, stünde use of moved value.
  • -->-Zeile: zeigt Datei, Zeile (5) und Spalte (20) des Fehlers.
  • Zeile 2: Der Grund für das Verschieben: s1 hat den Typ String, und String implementiert Copy nicht.
  • Zeile 3: Mit den ---Markierungen wird durch „value moved here“ die genaue Stelle des Verschiebens gezeigt.
  • Zeile 5: Das ^^-Zeichen markiert den Ausdruck, an dem der Fehler auftritt; hier wird versucht, den verschobenen Wert auszugeben.
  • help-Block: Der Compiler schlägt eine konkrete Korrektur vor: mit s1.clone() eine explizite Kopie anlegen.

Diese Meldung lesen zu lernen spart Zeit; der Compiler meldet den Fehler nicht nur, sondern schlägt meistens auch die Korrektur vor. Die offizielle Beschreibung des Fehlercodes findest du im rustc-Fehlerindex.

Unterschied zwischen Clone und Copy

Kurze Antwort Der Unterschied zwischen Rust Clone und Copy ist folgender: Copy ist ein Marker-Trait, bei dem der Compiler bei einer Zuweisung stillschweigend eine Bit-Kopie macht; Clone ist ein Trait, das Daten kopiert, indem explizit .clone() aufgerufen wird. Copy ist nur für einfache Typen geeignet, die auf dem Stack leben; Typen, die einen Heap besitzen, können nicht Copy sein.

Eigenschaft Copy Clone
Bedeutung Implizite Bit-Kopie Expliziter .clone()-Aufruf
Wann es greift Zuweisung, Funktionsparameter, Rückgabewert Nur bei manuellem Aufruf
Methode Keine, Marker-Trait fn clone(&self) -> Self
Geeignete Typen i32, f64, bool, char, &T, Tupel und Arrays, deren Elemente alle Copy sind, z. B. (i32, bool), [u8; 4] String, Vec<T>, HashMap<K, V>
Kosten Sehr gering, Stack-Kopie Kann Heap-Allokation enthalten

Du kannst beide Traits in deinen eigenen Structs ableiten; um Copy abzuleiten, müssen aber auch alle Felder Copy sein. Die offizielle Definition findest du auf der Seite std::marker::Copy.

#[derive(Debug, Clone, Copy)]
struct Nokta {
    x: i32,
    y: i32,
}

Warum ist String nicht Copy?

String besitzt einen Puffer auf dem Heap. Wäre es Copy, würden bei einer Zuweisung zwei Variablen auf denselben Puffer zeigen und beide würden am Ende des Gültigkeitsbereichs versuchen, denselben Speicher freizugeben; das würde zu einem Double-Free-Fehler führen. Deshalb bietet Rust für String statt Copy ein Clone an und erzwingt, dass das Kopieren explizit angefordert wird.

Werte an Funktionen übergeben und zurückholen

Kurze Antwort Wenn du die Ownership an eine Funktion übergibst, wird der Wert in die Funktion verschoben und kann auf der aufrufenden Seite nicht mehr verwendet werden; um den Wert zurückzubekommen, muss die Funktion ihn zurückgeben oder du musst den Wert mit &T ausleihen.

fn uzunluk_al(s: String) -> usize {
    s.len()
}

fn uzunluk_odunc(s: &str) -> usize {
    s.len()
}

fn unlem_ekle(mut s: String) -> String {
    s.push('!');
    s
}

fn main() {
    let metin = String::from("sahiplik");

    println!("uzunluk: {}", uzunluk_odunc(&metin));
    println!("metin hala burada: {}", metin);

    let metin = unlem_ekle(metin); // sahiplik verildi ve geri alındı
    println!("geri alindi: {}", metin);

    println!("uzunluk: {}", uzunluk_al(metin));
}
uzunluk: 8
metin hala burada: sahiplik
geri alindi: sahiplik!
uzunluk: 9

Hier stehen drei Strategien nebeneinander: uzunluk_odunc liest nur und gibt den Wert nicht zurück, unlem_ekle übernimmt die Ownership, verändert den Wert und gibt ihn zurück, uzunluk_al hingegen konsumiert die Ownership. In echten Projekten bevorzugst du für lesende Funktionen Referenzen; eine Ownership-Übergabe verwendest du nur, wenn du den Wert wirklich an die Funktion übergeben willst.

Der Aufruf uzunluk_al(metin) in der letzten Zeile konsumiert die Ownership, deshalb kann metin danach nicht mehr verwendet werden:

fn uzunluk_al(s: String) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk_al(metin));
    println!("{}", metin); // error[E0382]: borrow of moved value: `metin`
}

Einen Parameter als &str statt &String zu nehmen ist flexibler; sowohl String als auch ein String-Literal lassen sich in diesen Typ umwandeln. Wenn du den Wert an die Funktion geben und zurückbekommen musst, ist es auch gültig, ein Tupel zurückzugeben:

fn uzunluk_ve_geri(s: String) -> (String, usize) {
    let uzunluk = s.len();
    (s, uzunluk)
}

Diese Signatur funktioniert, erfordert aber bei jedem Aufruf das Entpacken des Tupels; in den meisten Fällen ist die Verwendung einer Referenz einfacher. Die Regeln des Borrowings behandeln wir in der nächsten Lektion der Serie.

Drop und das Ende des Gültigkeitsbereichs

Kurze Antwort Das Drop-Trait in Rust ist der Mechanismus, der die Ressourcen eines Werts freigibt, wenn sein Besitzer den Gültigkeitsbereich verlässt, und übernimmt die Aufgabe eines Destruktors. Der Compiler platziert den drop-Aufruf automatisch am Ende des Gültigkeitsbereichs.

struct Kayit {
    ad: String,
}

impl Drop for Kayit {
    fn drop(&mut self) {
        println!("{} kaydı bellekten temizlendi", self.ad);
    }
}

fn main() {
    let _a = Kayit { ad: String::from("birinci") };
    let _b = Kayit { ad: String::from("ikinci") };
    {
        let _c = Kayit { ad: String::from("ucuncu") };
        println!("iç kapsam bitti");
    }
    println!("dış kapsam bitiyor");
}
iç kapsam bitti
ucuncu kaydı bellekten temizlendi
dış kapsam bitiyor
ikinci kaydı bellekten temizlendi
birinci kaydı bellekten temizlendi

Die Reihenfolge der Ausgabe ist kein Zufall: _c im inneren Gültigkeitsbereich wird zuerst gedroppt, danach endet der äußere Gültigkeitsbereich. Gibt es im selben Gültigkeitsbereich mehrere Werte, räumt Rust sie in umgekehrter Reihenfolge ihrer Erstellung (LIFO) auf; deshalb wird _b vor _a gedroppt.

Die Drop-Reihenfolge ist bei Ressourcen wie Dateihandles und Locks wichtig; das Freigeben von Ressourcen in umgekehrter Reihenfolge stellt sicher, dass Abhängigkeiten sicher geschlossen werden.

Wenn du einen Wert vor dem Ende des Gültigkeitsbereichs freigeben willst, verwendest du std::mem::drop: Der Aufruf drop(a); konsumiert a sofort. Ein a.drop() hingegen kompiliert nicht; der Compiler meldet mit dem Fehler E0040 „explicit destructor calls not allowed“. Details findest du in der Dokumentation zu std::ops::Drop.

Warum Rust mit Ownership keinen Garbage Collector braucht

Kurze Antwort In Rust wird Speicher nicht von einem zur Laufzeit überwachten Garbage Collector freigegeben, sondern mithilfe von Ownership- und Gültigkeitsbereichsinformationen, die zur Compile-Zeit bekannt sind; deshalb gibt es keine GC-Pausen. Der Compiler platziert den Freigabepunkt direkt in den generierten Code.

In Sprachen mit Garbage Collector wird der Speicher zur Laufzeit durch einen Erreichbarkeits-Scan bereinigt. In Rust weiß der Compiler statisch, wo jeder Wert gedroppt wird; es gibt keinen zusätzlichen Wächter zur Laufzeit. Die Ownership-Prüfung ist ein Beispiel für Rusts Prinzip der Zero-Cost-Abstractions: Die Prüfungen enden zur Compile-Zeit und hinterlassen keine zusätzliche Last zur Laufzeit.

Thema C++ Go Rust
Speicherverwaltung Manuell; RAII und Smart Pointer Garbage Collector Ownership zur Compile-Zeit
Freigabe Destruktor GC Drop-Trait
Zugriff auf einen verschobenen Wert Kompiliert; das Objekt bleibt gültig, aber in einem unbestimmten Zustand (der Fehler wird nicht vom Compiler erkannt) Kein Move-Konzept; eine Zuweisung kopiert den Wert oder teilt sich den Header, der auf dieselben Daten zeigt, den Speicher verwaltet der GC Compile-Fehler (E0382)
Laufzeitkosten Keine GC-Pausen möglich Keine
Data-Race-Prüfung Manuell, mit Tools Race Detector zur Laufzeit Zur Compile-Zeit (Send/Sync)

Der Unterschied in der Tabelle erklärt, warum Rust sowohl C++-ähnliche Performance als auch Speichersicherheit verspricht. Der Preis dafür ist, dass du mehr mit dem Compiler sprichst und deine Ownership-Entscheidungen explizit im Code schreibst.

Häufige Fehler

1. Nach einem Move die alte Variable verwenden

Symptom Du erhältst die Meldung error[E0382]: borrow of moved value.
Ursache Eine Zuweisung oder ein Funktionsaufruf hat das Ownership übertragen, die alte Bindung ist jetzt ungültig.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1;
    println!("{}", s1); // Fehler: s1 wurde verschoben
    println!("{}", s2);
}

Lösung Verwende die Variable, an die verschoben wurde, oder fordere explizit eine Kopie an.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1.clone();
    println!("{} {}", s1, s2);
}

2. Überall clone aufrufen

Symptom Der Code kompiliert, aber es sammeln sich unnötige Heap-Allokationen an.
Ursache Weil clone() der einfachste Weg ist, den Compiler zum Schweigen zu bringen, wird es zum Reflex.

fn uzunluk(s: String) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk(metin.clone()));
}

Lösung Verwende in Funktionen, die nur lesen, einen &str-Parameter; hole eine Kopie nur, wenn wirklich zwei unabhängige Owner benötigt werden.

fn uzunluk(s: &str) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk(&metin));
}

3. Einen String an eine Funktion übergeben und ihn danach verwenden wollen

Symptom Wenn du dieselbe Variable nach dem Funktionsaufruf ausgeben willst, erzeugt das E0382.
Ursache Wenn der Parameter als String deklariert ist, geht das Ownership an die Funktion über.

fn yaz(s: String) {
    println!("{}", s);
}

fn main() {
    let metin = String::from("merhaba");
    yaz(metin);
    println!("{}", metin); // Fehler: metin wurde verschoben
}

Lösung Mache den Parameter zu &str und übergib beim Aufruf eine Referenz.

fn yaz(s: &str) {
    println!("{}", s);
}

fn main() {
    let metin = String::from("merhaba");
    yaz(&metin);
    println!("{}", metin);
}

4. Ein Struct-Feld verschieben und das Struct als Ganzes verwenden

Symptom Du siehst die Meldung error[E0382]: borrow of partially moved value: `k`.
Ursache Wenn ein Feld in eine andere Variable verschoben wird, wird das Struct teilweise ungültig.

#[derive(Debug)]
struct Kullanici {
    ad: String,
    yas: u32,
}

fn main() {
    let k = Kullanici { ad: String::from("Ada"), yas: 30 };
    let ad = k.ad;
    println!("{:?}", k); // Fehler: k wurde teilweise verschoben
    println!("{}", ad);
}

Lösung Leihe das Feld aus oder kopiere es explizit; so bleibt das Struct als Ganzes gültig.

#[derive(Debug)]
struct Kullanici {
    ad: String,
    yas: u32,
}

fn main() {
    let k = Kullanici { ad: String::from("Ada"), yas: 30 };
    let ad = k.ad.clone();
    println!("{:?}", k);
    println!("{}", ad);
}

Häufig gestellte Fragen

Warum gibt es Ownership in Rust?

Ownership existiert, um Speichersicherheit und die Kontrolle von Datenrennen ohne Laufzeitkosten zu gewährleisten. Der Compiler verhindert, dass zwei Owner auf denselben Speicher zeigen und dass auf freigegebene Daten zugegriffen wird, bevor das Programm läuft. Dadurch entfällt die Notwendigkeit eines Garbage Collectors.

Was ist der Unterschied zwischen Move und Copy in Rust?

Ein Move ist die Übertragung des Ownership und macht die alte Bindung ungültig; ein Copy erzeugt eine neue Kopie des Werts, und beide Bindungen bleiben verwendbar. Bei Typen, die das Copy-Trait implementieren, kopiert eine Zuweisung automatisch; bei anderen Typen verschiebt sie. Mit Clone forderst du die Kopie explizit an.

Warum ist String kein Copy?

String besitzt einen Puffer auf dem Heap; wäre es Copy, würden zwei Variablen auf denselben Puffer zeigen, und am Ende des Gültigkeitsbereichs würde derselbe Speicher zweimal freigegeben. Rust verhindert dieses Risiko der doppelten Freigabe, indem es für String Clone statt Copy anbietet.

Beeinträchtigt die Verwendung von clone die Performance?

Bei Heap-besitzenden Typen wie String und Vec führt clone() eine neue Allokation und Datenkopie durch; bei Copy-Typen wie i32 oder innerhalb von Rc/Arc sind die Kosten sehr gering. Häufig aufgerufenes clone() in heißen Schleifen verursacht messbare Kosten. Deshalb bevorzugt man in Funktionen, die nur lesen, eine Referenz und verwendet clone(), wenn wirklich eine unabhängige Kopie benötigt wird.

Zusammenfassung und nächste Lektion

  • Jeder Wert hat genau einen Owner; wenn der Owner den Gültigkeitsbereich verlässt, wird der Wert mit Drop aufgeräumt.
  • Zuweisungen und Funktionsaufrufe führen standardmäßig einen Move aus; die alte Bindung wird ungültig, und wenn du sie verwenden willst, erhältst du E0382.
  • Copy ist eine implizite und günstige Bit-Kopie, Clone eine explizite und potenziell teure Kopie.
  • Statt Ownership zu übertragen, ist es meist die richtige Wahl, mit &T oder &str auszuleihen.
  • Dank dieses Modells gewährleistet Rust Speichersicherheit ohne Garbage Collector.

In der nächsten Lektion der Serie behandeln wir die Borrowing-Regeln, die unvermeidliche Ergänzung zum Ownership, die Referenzen & und &mut sowie die Fehler, die der Rust Borrow Checker meldet.

Ressourcen

  1. doc.rust-lang.org doc.rust-lang.org

Lektion abgeschlossen · 1 / 1

Du hast diese Lektion abgeschlossen

Die nächste Lektion der Serie wird vorbereitet. Abonniere den Kanal, um sie nicht zu verpassen, wenn sie erscheint.

Wenn es hilfreich war, teile es

Kommentar schreiben