Learn Rust Coding · Lektion

Das Ownership-Modell von Rust verstehen

Verstehen Sie die grundlegenden Regeln von Ownership und Move-Semantik und wie sie häufige Speicherfehler wie Double-Free verhindern.

Lektion 1 von 312 Schritte

Das Ownership-Modell von Rust verstehen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was ist Ownership in Rust?

Das Ownership-System von Rust besteht aus Regeln, die festlegen, wie Ihr Programm den Speicher verwendet. Es ist ein zentrales Konzept, mit dem Rust Speichersicherheit ohne Garbage Collector erreicht.

Keine hängenden Zeiger.
Keine Double-Free-Fehler.
Keine Data Races in nebenläufigem Code.

Diese Regeln werden bereits zur Kompilierzeit überprüft!

Stack- und Heap-Speicher

Programme verwenden zwei wichtige Speicherbereiche: den Stack und den Heap.

Stack: Schnellere Daten fester Größe (z. B. Ganzzahlen, boolesche Werte und Typen bekannter Größe). Daten werden der Reihe nach abgelegt und entfernt.
Heap: Langsamere Daten variabler Größe (z. B. String, Vec). Der Speicher wird vom Allokator angefordert und wieder freigegeben.

Ownership verwaltet hauptsächlich Daten auf dem Heap und stellt deren sichere Verwendung und Freigabe sicher.

Regel 1: Jeder Wert hat einen Besitzer

Die erste Ownership-Regel ist einfach: Jeder Wert in Rust hat eine Variable, die als sein Besitzer bezeichnet wird.

Stellen Sie sich das wie ein Etikett auf einer Kiste vor. Die Variable s unten ist der Besitzer des Textes "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

Regel 2: Immer nur ein Besitzer

Die zweite Regel lautet: Zu jedem Zeitpunkt kann es für einen Wert nur einen Besitzer geben. Das ist entscheidend, um Speicherprobleme zu verhindern.

Wenn Sie einen komplexen Wert (z. B. einen String, der auf dem Heap liegt) von einer Variable einer anderen zuweisen, wird die Ownership verschoben, nicht kopiert.

Ownership-Übertragung in Aktion

Sehen Sie, was passiert, wenn der Wert von s1 s2 zugewiesen wird. Führen Sie den Code aus.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

Die Semantik von „Move“ verstehen

Nach let s2 = s1; gilt s1 nicht mehr als gültig. Rust verhindert, dass Sie s1 erneut verwenden.

Dies wird als Move bezeichnet. Der Zeiger, die Länge und die Kapazität auf dem Stack werden kopiert, die Heap-Daten selbst jedoch nicht.
Wäre s1 weiterhin gültig, würden sowohl s1 als auch s2 versuchen, denselben Speicher freizugeben, sobald sie ihren Gültigkeitsbereich verlassen (ein Double-Free-Fehler).

Das Ownership-System von Rust verhindert dies bereits zur Kompilierzeit!

Ownership und Funktionsaufrufe

Die Übergabe eines Werts an eine Funktion funktioniert ähnlich wie die Zuweisung an eine andere Variable: Die Ownership wird an die Funktion übertragen.

Wenn die Funktion beendet wird, verlässt der Besitzer des Werts (der Funktionsparameter) seinen Gültigkeitsbereich und der Wert wird verworfen.

Ownership-Demo mit Funktionen

Beobachten Sie, wie der String-Wert an takes_ownership verschoben wird und gives_ownership anschließend einen neuen String zurückgibt.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

Regel 3: Gültigkeitsbereich und Verwerfen

Die letzte Regel lautet: Wenn der Besitzer seinen Gültigkeitsbereich verlässt, wird der Wert verworfen.

Ein Gültigkeitsbereich ist der Bereich eines Programms, in dem ein Element gültig ist; normalerweise wird er durch geschweifte Klammern {} definiert.
Wenn eine Variable ihren Gültigkeitsbereich verlässt, ruft Rust automatisch eine spezielle Funktion namens drop auf.

Dadurch wird sichergestellt, dass der Speicher automatisch, sicher und ohne Garbage Collector bereinigt wird.

Speicherfehler verhindern

Die Ownership-Regeln wirken zusammen und garantieren Speichersicherheit:

Ein Besitzer: Verhindert, dass mehrere Teile Ihres Codes versuchen, denselben Speicher freizugeben.
Verwerfen am Ende des Gültigkeitsbereichs: Stellt sicher, dass Speicher genau einmal und zum richtigen Zeitpunkt freigegeben wird.

Dadurch werden häufige Fehler wie Double-Free- und Use-after-Free-Fehler bereits zur Kompilierzeit verhindert – das gibt Ihnen Sicherheit!

Ownership-Prüfung

Betrachten Sie den folgenden Rust-Code. Was passiert, wenn Sie versuchen, ihn zu kompilieren und auszuführen?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Beantworte es in der interaktiven Lektion

Rückblick: Ownership-Grundlagen

Sehr gut! Sie haben die grundlegenden Regeln des Ownership-Systems von Rust kennengelernt:

Jeder Wert hat einen Besitzer.
Es kann immer nur einen Besitzer geben.
Wenn der Besitzer seinen Gültigkeitsbereich verlässt, wird der Wert verworfen.

Dieses System verhindert häufige Speicherfehler ohne Garbage Collector. Als Nächstes sehen wir uns Borrowing an, um Daten gemeinsam zu nutzen, ohne die Ownership zu übertragen.

Kostenlos starten

Lerne Rust mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 144

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Das Ownership-Modell von Rust verstehen“ kostenlos?

Ja — der vollständige Text von „Das Ownership-Modell von Rust verstehen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Das Ownership-Modell von Rust verstehen“?

Verstehen Sie die grundlegenden Regeln von Ownership und Move-Semantik und wie sie häufige Speicherfehler wie Double-Free verhindern. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Das Ownership-Modell von Rust verstehen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding