Learn Rust Coding · Lektion

Lifetimes für sichere Referenzen

Vertiefen Sie Ihr Verständnis von Lifetimes, dem Mechanismus von Rust, der die Gültigkeit von Referenzen sicherstellt und Dangling Pointer bereits zur Compile-Zeit verhindert.

Lifetimes für sichere Referenzen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Warum Lifetimes wichtig sind

Die Ownership- und Borrowing-Regeln von Rust verhindern viele häufige Speicherfehler. Es gibt jedoch noch eine weitere Sicherheitsebene: Lifetimes.

Lifetimes stellen sicher, dass Referenzen in Ihrem Code immer auf gültige Daten verweisen. Sie lösen das Problem von hängenden Referenzen, bei denen eine Referenz auf Speicher verweisen könnte, der bereits freigegeben wurde.

Das Risiko hängender Pointer

Stellen Sie sich vor, eine Funktion erstellt Daten, gibt eine Referenz darauf zurück und die Daten werden anschließend beim Beenden der Funktion zerstört. Die zurückgegebene Referenz würde dann auf ungültigen Speicher verweisen.

Rust verhindert dies mithilfe von Lifetimes bereits zur Compilezeit. Der Compiler prüft, ob jede verwendete Referenz so lange gültig bleibt, wie Sie sie benötigen, und gewährleistet dadurch die Speichersicherheit.

Rust leitet Lifetimes ab

Sie müssen Lifetime-Annotationen nicht immer explizit angeben. Rust verfügt über eine Reihe von Regeln zur Lifetime-Auslassung, mit denen der Compiler Lifetimes in häufig vorkommenden Mustern ableiten kann.

In einer Funktion mit einer Eingabereferenz wird deren Lifetime beispielsweise häufig automatisch der Ausgabereferenz zugewiesen. Dadurch bleibt Ihr Code übersichtlicher!

Wann Annotationen erforderlich sind

Wenn Rust Lifetimes nicht ableiten kann, müssen Sie sie explizit annotieren. Dadurch teilen Sie dem Compiler mit, in welcher Beziehung die Lifetimes verschiedener Referenzen zueinander stehen.

Die Syntax für eine Lifetime-Annotation besteht aus einem Apostroph, gefolgt von einem Kleinbuchstaben, zum Beispiel 'a. Dabei handelt es sich um einen generischen Parameter für Lifetimes, nicht um eine bestimmte Zeitdauer.

Lifetime-Parameter von Funktionen

Wenn eine Funktion mehrere Referenzen entgegennimmt und eine zurückgibt, muss Rust wissen, die Lifetime welcher Eingabereferenz die Ausgabereferenz haben soll. Dadurch wird sichergestellt, dass die zurückgegebene Referenz immer gültig ist.

Mit der Syntax <'a> wird ein generischer Lifetime-Parameter deklariert. Sehen wir uns ein Beispiel an:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  if x.len() > y.len() {
    x
  } else {
    y
  }
}

fn main() {
  let string1 = String::from("abcd");
  let string2 = "xyz";
  let result = longest(string1.as_str(), string2);
  println!("The longest string is: {}", result);
}

Die Lifetime 'static

Die Lifetime 'static ist ein Sonderfall. Sie gibt an, dass eine Referenz während der gesamten Laufzeit des Programms bestehen kann.

String-Literale (zum Beispiel "hello world") haben die Lifetime 'static, weil sie direkt in der Binärdatei des Programms gespeichert werden und während der gesamten Ausführung verfügbar sind.

fn main() {
  // 'static lifetime for a string literal
  let s: &'static str = "I live for the entire program!";
  println!("{}", s);

  // This is also implicitly 'static
  let another_s = "Hello from static land!";
  println!("{}", another_s);
}

Structs mit Referenzen

Wenn ein Struct eine Referenz enthält, müssen Sie der Definition des Structs eine Lifetime-Annotation hinzufügen. Dadurch wird sichergestellt, dass keine Instanz des Structs länger besteht als die Daten, auf die ihre Referenzen verweisen.

Der Lifetime-Parameter des Structs teilt Rust mit, dass alle darin enthaltenen Referenzen mindestens diese Lifetime haben müssen.

struct ImportantExcerpt<'a> {
  part: &'a str,
}

fn main() {
  let novel = String::from("Call me Ishmael. Some years ago...");
  let first_sentence = novel.split('.').next().expect("Could not find a '.'");
  let i = ImportantExcerpt {
    part: first_sentence,
  };
  println!("Excerpt part: {}", i.part);
}

Lifetimes mit Generics

Lifetimes sind eine Form von Generics! Sie können sie mit generischen Typparametern kombinieren, um flexible und sichere Datenstrukturen oder Funktionen zu erstellen.

Ein Struct könnte beispielsweise Referenzen auf generische Typen enthalten, die alle durch einen einzigen Lifetime-Parameter beschränkt sind. Dadurch bleiben auch komplexe Datenbeziehungen gültig.

Compilerfehler entschlüsseln

Wenn Sie zum ersten Mal auf Lifetime-Fehler stoßen, können diese einschüchternd wirken. Der häufigste Fehler lautet „borrow might not live long enough“.

Das bedeutet normalerweise, dass Sie versuchen, eine Referenz zu verwenden, nachdem die Daten, auf die sie verweist, gelöscht wurden, oder dass Rust ihre Gültigkeit nicht nachweisen kann. Wenn Sie diese Meldungen verstehen, können Sie Ihre Lifetime-Annotationen entsprechend anpassen.

Kurzer Test: Lifetimes

Welche der folgenden Aussagen beschreibt am besten das grundlegende Problem, das explizite Lifetime-Annotationen von Rust lösen sollen?

Lifetimes: Sicherheit zur Compilezeit

Sie haben gelernt, dass Lifetimes ein wichtiger Bestandteil der Speichersicherheitsgarantien von Rust sind. Sie verhindern hängende Referenzen, indem sie sicherstellen, dass alle Referenzen während ihrer gesamten Verwendung gültig sind.

Rust leitet Lifetimes häufig mithilfe von Regeln zur Auslassung ab.
Wenn eine Ableitung nicht möglich ist, verwenden Sie explizite Annotationen wie 'a.
Lifetimes sind für Funktionen, die Referenzen zurückgeben, und für Structs mit Referenzen unverzichtbar.
Die besondere Lifetime 'static gilt während der gesamten Laufzeit des Programms.

Wer Lifetimes beherrscht, kann robusten Rust-Code schreiben!

Häufig gestellte Fragen

Ist die Lektion „Lifetimes für sichere Referenzen“ kostenlos?

Ja — der vollständige Text von „Lifetimes für sichere Referenzen“ 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 „Lifetimes für sichere Referenzen“?

Vertiefen Sie Ihr Verständnis von Lifetimes, dem Mechanismus von Rust, der die Gültigkeit von Referenzen sicherstellt und Dangling Pointer bereits zur Compile-Zeit verhindert. 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 3 von 3.

Wie lange dauert die Lektion „Lifetimes für sichere Referenzen“?

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