Learn Rust Coding · Lektion

Interior Mutability: RefCell, Cell

Lernen Sie `RefCell` und `Cell` für Interior Mutability kennen, die sicheren veränderlichen Zugriff auf Daten über eine unveränderliche Referenz ermöglichen.

Interior Mutability: RefCell, Cell ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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 Interior Mutability?

In Rust verhindern die Borrowing-Regeln normalerweise, dass Sie eine veränderbare Referenz auf Daten besitzen, wenn bereits eine unveränderliche Referenz darauf existiert. Dadurch wird die Datensicherheit gewährleistet.

Interior Mutability ist ein Entwurfsmuster, mit dem Sie Daten auch dann verändern können, wenn Sie nur eine unveränderliche Referenz darauf besitzen. Es ist wie eine kontrollierte Ausnahme von den üblichen Regeln von Rust, die in bestimmten Situationen verwendet wird.

`Cell<T>`: Für Copy-Typen

Der Typ Cell<T> stellt Interior Mutability für Typen bereit, die das Trait Copy implementieren (z. B. Ganzzahlen, boolesche Werte und Zeichen). Dazu wird der enthaltene Wert ersetzt.

get(): Gibt eine Kopie des Werts in der Cell zurück.
set(value): Ersetzt den Wert in der Cell durch einen neuen.

Das ist einfach und effizient für kleine, kopierbare Daten.

Mit `Cell` Werte aktualisieren

Hier sehen Sie ein einfaches Beispiel für Cell. Beachten Sie, dass wir den Wert in der Cell ändern können, obwohl die Cell selbst als unveränderlich deklariert ist.

use std::cell::Cell;

fn main() {
  let my_num = Cell::new(10);
  println!("Initial value: {}", my_num.get());

  my_num.set(20);
  println!("Updated value: {}", my_num.get());

  let x = &my_num;
  x.set(30); // Still works via immutable reference!
  println!("Via immutable ref: {}", my_num.get());
}

`RefCell<T>`: Für Nicht-Copy-Typen

Wenn Sie interne Veränderbarkeit für Typen benötigen, die nicht Copy implementieren (z. B. String, Vec oder benutzerdefinierte Structs), verwenden Sie RefCell<T>.

RefCell ermöglicht Ihnen, veränderbare Referenzen auf die enthaltenen Daten zu erhalten. Es setzt die Ausleihregeln von Rust jedoch erst zur Laufzeit und nicht zur Kompilierzeit durch.

Ausleihen zur Laufzeit mit `RefCell`

RefCell stellt Methoden bereit, die Smart Pointer zurückgeben:

borrow(): Gibt eine Ref zurück (einen unveränderlichen Smart Pointer). Sie können gleichzeitig mehrere unveränderliche Ausleihen haben.
borrow_mut(): Gibt eine RefMut zurück (einen veränderlichen Smart Pointer). Sie können immer nur eine veränderliche Ausleihe gleichzeitig haben.

Wenn Sie diese Regeln zur Laufzeit verletzen, führt Ihr Programm zu einem panic!.

`RefCell` verwenden (unveränderliche Ausleihe)

Hier verwenden wir borrow(), um eine unveränderliche Referenz auf den String innerhalb der RefCell zu erhalten. Wir können seinen Inhalt ausgeben.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("Hello"));

  let s1 = my_string_cell.borrow();
  println!("Value: {}", *s1); // Dereference Ref to get String

  let s2 = my_string_cell.borrow(); // Multiple immutable borrows are fine
  println!("Another value: {}", *s2);
}

`RefCell` verwenden (veränderliche Ausleihe)

Rufen wir nun mit borrow_mut() eine veränderliche Referenz ab. Dadurch können wir den String ändern. Beachten Sie, dass keine weiteren Ausleihen (weder veränderliche noch unveränderliche) zulässig sind, sobald s_mut im Gültigkeitsbereich ist.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("World"));

  { // Scope for the mutable borrow
    let mut s_mut = my_string_cell.borrow_mut();
    s_mut.push_str(", Rust!");
  }
  // s_mut is out of scope here, so we can borrow again

  let s_final = my_string_cell.borrow();
  println!("Final value: {}", *s_final);
}

Der Laufzeit-Panic von `RefCell`

Wenn Sie eine veränderliche Ausleihe anfordern, während eine andere veränderliche Ausleihe (oder eine beliebige unveränderliche Ausleihe) aktiv ist, führt RefCell Ihr Programm zur Laufzeit zu einem panic!. Dadurch wird eine Beschädigung der Daten verhindert.

Führen Sie diesen Code aus, um das Verhalten zu sehen! Das Programm wird mit dem Fehler „borrow already in use“ abstürzen.

use std::cell::RefCell;

fn main() {
  let my_value = RefCell::new(vec![1, 2, 3]);

  let _first_mut_borrow = my_value.borrow_mut();
  println!("First mutable borrow is active.");

  // This line will cause a runtime panic!
  // Try commenting it out to see the program run successfully.
  let _second_mut_borrow = my_value.borrow_mut();

  println!("This line will not be reached.");
}

Zusammenfassung: `Cell` vs. `RefCell`

Die Wahl zwischen Cell und RefCell hängt von Ihrem Datentyp und der Art ab, wie Sie darauf zugreifen müssen:

Cell<T>: Verwenden Sie diesen Typ für Typen, die Copy implementieren. Er ersetzt den gesamten Wert und ist im Allgemeinen einfacher und leistungsfähiger.
RefCell<T>: Verwenden Sie diesen Typ für Typen, die Copy nicht implementieren. Er stellt Referenzen auf die enthaltenen Daten bereit und setzt die Ausleihregeln zur Laufzeit durch, wodurch komplexere Änderungen möglich werden.

Kurztest: Cell oder RefCell?

Sie haben ein struct, das einen veränderlichen Zähler (u32) und eine veränderliche Namensliste (Vec<String>) speichern muss. Beide müssen über eine unveränderliche Referenz auf das struct aktualisiert werden. Welche Typen für interne Veränderbarkeit würden Sie für die einzelnen Felder verwenden?

Rückblick: Interne Veränderbarkeit

Sie haben das Muster der internen Veränderbarkeit in Rust kennengelernt. Es ermöglicht, Daten kontrolliert und sicher über eine unveränderliche Referenz zu ändern.

Cell<T>: Für Copy-Typen; ersetzt den enthaltenen Wert.
RefCell<T>: Für Typen ohne Copy; stellt zur Laufzeit geprüfte veränderliche und unveränderliche Referenzen bereit.
Eine Verletzung der Regeln von RefCell führt zu einem Panic zur Laufzeit und gewährleistet so die Sicherheit.

Diese Typen sind entscheidend für Muster wie Mock-Objekte, zirkuläre Referenzen oder Situationen, in denen eine gemeinsam genutzte unveränderliche Referenz den internen Zustand verfolgen muss.

Häufig gestellte Fragen

Ist die Lektion „Interior Mutability: RefCell, Cell“ kostenlos?

Ja — der vollständige Text von „Interior Mutability: RefCell, Cell“ 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 „Interior Mutability: RefCell, Cell“?

Lernen Sie `RefCell` und `Cell` für Interior Mutability kennen, die sicheren veränderlichen Zugriff auf Daten über eine unveränderliche Referenz ermöglichen. 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 2 von 3.

Wie lange dauert die Lektion „Interior Mutability: RefCell, Cell“?

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