Leer programmeren met Rust · Les

Interior mutability: RefCell, Cell

Leer meer over `RefCell` en `Cell` voor interior mutability, waarmee u veilig veranderlijke toegang tot gegevens krijgt via een onveranderlijke reference.

Les 2 van 311 stappen

Interior mutability: RefCell, Cell is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 2 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Wat is interne veranderlijkheid?

In Rust voorkomen de leenregels meestal dat je een veranderlijke verwijzing naar gegevens hebt als je al een onveranderlijke verwijzing ernaar hebt. Zo wordt de veiligheid van gegevens gewaarborgd.

Interne veranderlijkheid is een ontwerppatroon waarmee je gegevens kunt wijzigen, zelfs wanneer je alleen een onveranderlijke verwijzing ernaar hebt. Het is vergelijkbaar met een gecontroleerde uitzondering op de gebruikelijke regels van Rust, die je in specifieke situaties gebruikt.

`Cell<T>`: voor typen die Copy implementeren

Het type Cell<T> biedt interne veranderlijkheid voor typen die de trait Copy implementeren, zoals gehele getallen, booleans en tekens. Het werkt door de waarde binnenin te vervangen.

get(): retourneert een kopie van de waarde in de Cell.
set(value): vervangt de waarde in de Cell door een nieuwe waarde.

Dit is eenvoudig en efficiënt voor kleine, kopieerbare gegevens.

`Cell` gebruiken om waarden bij te werken

Hier is een eenvoudig voorbeeld van Cell. Let op hoe we de waarde in de Cell kunnen wijzigen, ook al is de Cell zelf als onveranderlijk gedeclareerd.

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>`: voor typen die Copy niet implementeren

Wanneer je interne veranderlijkheid nodig hebt voor typen die geen Copy implementeren (zoals String, Vec of aangepaste structuren), gebruik je RefCell<T>.

Met RefCell kun je veranderlijke referenties naar de interne gegevens krijgen, maar worden de leenregels van Rust afgedwongen tijdens het uitvoeren, niet tijdens het compileren.

Lenen tijdens runtime met `RefCell`

RefCell biedt methoden die slimme pointers teruggeven:

borrow(): geeft een Ref terug (een onveranderlijke slimme pointer). Je kunt meerdere onveranderlijke leningen tegelijk hebben.
borrow_mut(): geeft een RefMut terug (een veranderlijke slimme pointer). Je kunt maar één veranderlijke lening tegelijk hebben.

Als je deze regels tijdens het uitvoeren overtreedt, veroorzaakt je programma een panic!.

`RefCell` gebruiken (onveranderlijk lenen)

Hier gebruiken we borrow() om een onveranderlijke referentie te krijgen naar de String in de RefCell. We kunnen de inhoud ervan afdrukken.

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` gebruiken (veranderlijk lenen)

Nu krijgen we met borrow_mut() een veranderlijke referentie. Daarmee kunnen we de String aanpassen. Let op: zodra s_mut binnen bereik is, zijn er geen andere leningen (veranderlijk of onveranderlijk) toegestaan.

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);
}

De runtime-paniek van `RefCell`

Als je een veranderlijke lening probeert te krijgen terwijl er al een andere veranderlijke lening (of een willekeurige onveranderlijke lening) actief is, veroorzaakt RefCell tijdens het uitvoeren een panic! in je programma. Zo wordt beschadiging van gegevens voorkomen.

Voer deze code uit om het in actie te zien! De code stopt met een foutmelding: "borrow already in use".

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.");
}

Samenvatting: `Cell` versus `RefCell`

De keuze tussen Cell en RefCell hangt af van je gegevenstype en van de manier waarop je ermee wilt werken:

Cell<T>: gebruik je voor typen die Copy implementeren. De volledige waarde wordt vervangen; dit is meestal eenvoudiger en performanter.
RefCell<T>: gebruik je voor typen die Copy niet implementeren. Het biedt referenties naar de interne gegevens en dwingt de leenregels tijdens het uitvoeren af, waardoor complexere wijzigingen mogelijk zijn.

Korte controle: Cell of RefCell?

Je hebt een struct waarin een veranderlijke teller (u32) en een veranderlijke lijst met namen (Vec<String>) moeten worden opgeslagen. Beide moeten worden bijgewerkt via een onveranderlijke referentie naar de struct. Welke typen voor interne veranderlijkheid zou je voor elk veld gebruiken?

Beantwoord dit in de interactieve les

Herhaling: interne veranderlijkheid

Je hebt het patroon voor interne veranderlijkheid van Rust geleerd. Hiermee kun je gegevens op een gecontroleerde en veilige manier wijzigen via een onveranderlijke referentie.

Cell<T>: voor typen met Copy; vervangt de interne waarde.
RefCell<T>: voor typen zonder Copy; biedt tijdens het uitvoeren gecontroleerde veranderlijke en onveranderlijke referenties.
Als je de regels van RefCell overtreedt, ontstaat er tijdens het uitvoeren een paniek, wat de veiligheid waarborgt.

Deze typen zijn essentieel voor patronen zoals nepobjecten, circulaire referenties en situaties waarin een gedeelde onveranderlijke referentie de interne toestand moet bijhouden.

Gratis beginnen

Leer Rust met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Interior mutability: RefCell, Cell” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Interior mutability: RefCell, Cell”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Wat leer ik in “Interior mutability: RefCell, Cell”?

Leer meer over `RefCell` en `Cell` voor interior mutability, waarmee u veilig veranderlijke toegang tot gegevens krijgt via een onveranderlijke reference. Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 3.

Hoe lang duurt de les “Interior mutability: RefCell, Cell”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Leer programmeren met Rust