Referenzen und Borrowing erklärt

In Rust besitzen Variablen ihre Daten. Doch was ist, wenn andere Teile Ihres Codes diese Daten ansehen oder sogar ändern sollen, ohne die Ownership zu übernehmen?

Hier kommen Referenzen ins Spiel! Eine Referenz ist wie ein Zeiger auf einen Wert, unterliegt jedoch strengen Regeln, die vom Rust-Compiler durchgesetzt werden.

Stellen Sie sich vor, Sie betrachten etwas durch ein Fenster, anstatt den Gegenstand selbst zu besitzen.

Wir erstellen eine Referenz mit dem Operator &. Dadurch entsteht ein nicht besitzender Zeiger auf einen Wert. Sehen wir uns das in Aktion an:

Wenn Sie eine Referenz auf einen Wert erstellen, leihen Sie diesen Wert aus. Der Besitzer bleibt weiterhin Besitzer, aber Sie erhalten vorübergehenden Zugriff.

• Ausleihen statt Übergeben: Sie können die ausgeliehenen Daten verwenden.
• Keine Übertragung der Ownership: Die ursprüngliche Variable besitzt die Daten weiterhin und verwirft sie, wenn sie ihren Gültigkeitsbereich verlässt.
• Sicherheit an erster Stelle: Die Borrowing-Regeln von Rust verhindern häufige Programmierfehler wie Data Races.

Standardmäßig sind Referenzen in Rust unveränderlich. Das bedeutet, dass Sie die Daten, auf die sie verweisen, lesen, aber nicht ändern können.

Dies ist ein wichtiges Sicherheitsmerkmal! Wenn mehrere Teile Ihres Codes Lesezugriff haben, können sie nicht versehentlich die Daten der jeweils anderen beeinflussen.

Hier nimmt die Funktion calculate_sum eine unveränderliche Referenz auf einen Vektor entgegen. Sie kann die Elemente lesen, aber keine hinzufügen oder entfernen.

Manchmal müssen Sie geliehene Daten ändern. Dafür verwenden Sie eine veränderbare Referenz, dargestellt durch &mut.

Für veränderbare Referenzen gilt eine wichtige Regel: Zu einem bestimmten Zeitpunkt darf es nur eine veränderbare Referenz auf einen bestimmten Datenabschnitt geben. Dadurch werden Data Races verhindert und die Sicherheit gewährleistet.

Die Funktion add_suffix nimmt eine veränderbare Referenz auf einen String entgegen. Sie kann den ursprünglichen String direkt ändern.

Der Compiler von Rust setzt diese Regeln bereits zur Compilezeit durch, um Speichersicherheit zu garantieren:

• Sie dürfen gleichzeitig eine veränderbare Referenz auf einen Datenabschnitt haben.
• ODER Sie dürfen gleichzeitig beliebig viele unveränderbare Referenzen haben.
• Solange aktive unveränderbare Referenzen vorhanden sind, dürfen Sie keine veränderbare Referenz haben.
• Referenzen müssen immer gültig sein (sie dürfen die Daten, auf die sie verweisen, nicht überleben).

Diese Regeln verhindern Data Races und sorgen dafür, dass Ihre Programme sicher und vorhersehbar sind.

Dieser Code versucht, gleichzeitig eine unveränderbare und eine veränderbare Referenz auf my_value zu erstellen. Das verstößt gegen die Borrowing-Regeln von Rust. Der Code wird NICHT kompiliert.

Versuchen Sie, ihn auszuführen, und sehen Sie sich die Fehlermeldung des Compilers an!

Betrachten Sie den folgenden Rust-Codeausschnitt:

fn process_data(data: &mut Vec<i32>) {
  data.push(4);
}

fn main() {
  let mut numbers = vec![1, 2, 3];
  let first_ref = &numbers[0]; // Line A
  process_data(&mut numbers); // Line B
  println!("First element: {}", first_ref); // Line C
}

Welche Zeile(n) verursachen aufgrund der Borrowing-Regeln von Rust einen Fehler zur Compilezeit?

Sehr gut! Sie haben die Grundlagen von Referenzen und Borrowing in Rust gelernt:

• Referenzen (&) ermöglichen den Zugriff auf Daten, ohne deren Besitz zu übernehmen.
• Borrowing bezeichnet das Erstellen einer Referenz, also das Verleihen des Zugriffs auf Daten.
• Unveränderbare Referenzen (&) ermöglichen schreibgeschützten Zugriff.
• Veränderbare Referenzen (&mut) ermöglichen Lese- und Schreibzugriff.
• Die strengen Borrowing-Regeln von Rust (eine veränderbare ODER viele unveränderbare Referenzen) verhindern Data Races und gewährleisten die Speichersicherheit zur Compilezeit.

Diese Konzepte sind entscheidend, um sicheren und effizienten Rust-Code zu schreiben!