Leer programmeren met Rust · Les

Het ownershipmodel van Rust begrijpen

Krijg inzicht in de basisregels van ownership en move-semantiek, en ontdek hoe deze veelvoorkomende geheugenfouten zoals double-free voorkomen.

Les 1 van 312 stappen

Het ownershipmodel van Rust begrijpen is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 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 eigenaarschap in Rust?

Het eigenaarschapssysteem van Rust is een geheel van regels voor het beheer van de manier waarop je programma geheugen gebruikt. Het is een kernconcept waarmee Rust geheugenveiligheid kan bieden zonder garbagecollector.

Geen bungelende pointers.
Geen fouten door dubbel vrijgeven.
Geen dataraces in gelijktijdige code.

Rust controleert deze regels tijdens het compileren!

Stackgeheugen tegenover heapgeheugen

Programma's gebruiken twee belangrijke geheugengebieden: de stack en de heap.

Stack: Snellere gegevens met een vaste grootte (zoals gehele getallen, booleans en typen met een bekende grootte). Gegevens worden in volgorde op de stack geplaatst en er weer afgehaald.
Heap: Tragere gegevens met een variabele grootte (zoals String en Vec). De allocator reserveert ruimte voor deze gegevens en geeft die weer vrij.

Eigenaarschap beheert voornamelijk gegevens op de heap, zodat deze veilig worden gebruikt en opgeruimd.

Regel 1: elke waarde heeft een eigenaar

De eerste regel van eigenaarschap is eenvoudig: elke waarde in Rust heeft een variabele die de eigenaar ervan wordt genoemd.

Zie het als een label op een doos. De variabele s hieronder is de eigenaar van de tekst "hello".

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

Regel 2: slechts één eigenaar tegelijk

De tweede regel luidt: een waarde kan op elk moment maar één eigenaar hebben. Dit is cruciaal om geheugenproblemen te voorkomen.

Wanneer je een complexe waarde (zoals een String, die op de heap staat) van de ene variabele aan een andere toewijst, wordt het eigenaarschap verplaatst en niet gekopieerd.

Eigenaarschap overdragen in actie

Bekijk wat er gebeurt wanneer de waarde van s1 aan s2 wordt toegewezen. Probeer de code uit te voeren.

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

De semantiek van "verplaatsen" begrijpen

Na let s2 = s1; wordt s1 niet langer als geldig beschouwd. Rust voorkomt dat je s1 opnieuw gebruikt.

Dit heet een verplaatsing. De pointer, lengte en capaciteit op de stack worden gekopieerd, maar de heapgegevens zelf niet.
Als s1 nog geldig zou zijn, zouden zowel s1 als s2 proberen hetzelfde geheugen vrij te geven wanneer ze buiten bereik komen (een fout door dubbel vrijgeven).

Het eigenaarschapssysteem van Rust voorkomt dit tijdens het compileren!

Eigenaarschap en functieaanroepen

Een waarde aan een functie doorgeven werkt vergelijkbaar met het toewijzen ervan aan een andere variabele: het eigenaarschap wordt naar de functie verplaatst.

Wanneer de functie klaar is, valt de eigenaar van de waarde (de functieparameter) buiten bereik en wordt de waarde verwijderd.

Demonstratie van eigenaarschap bij functies

Bekijk hoe de waarde van String naar takes_ownership wordt verplaatst en hoe gives_ownership vervolgens een nieuwe String teruggeeft.

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: bereik en verwijderen

De laatste regel: wanneer de eigenaar buiten bereik komt, wordt de waarde verwijderd.

Een bereik is het gedeelte van een programma waarin een item geldig is, meestal afgebakend door accolades {}.
Wanneer een variabele buiten bereik komt, roept Rust automatisch een speciale functie aan met de naam drop.

Zo wordt geheugen automatisch, veilig en zonder garbagecollector opgeruimd.

Geheugenfouten voorkomen

De regels voor eigenaarschap werken samen om geheugenveiligheid te garanderen:

Eén eigenaar: Voorkomt dat meerdere delen van je code proberen hetzelfde geheugen vrij te geven.
Verwijderen aan het einde van het bereik: Zorgt ervoor dat geheugen precies één keer en op het juiste moment wordt vrijgegeven.

Hierdoor worden veelvoorkomende fouten zoals fouten door dubbel vrijgeven en fouten door gebruik na vrijgave tijdens het compileren geëlimineerd. Dat geeft je een gerust gevoel!

Controle van eigenaarschap

Bekijk de volgende Rust-code. Wat gebeurt er wanneer je deze probeert te compileren en uit te voeren?

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

Beantwoord dit in de interactieve les

Samenvatting: de basis van eigenaarschap

Goed gedaan! Je hebt de fundamentele regels van het eigenaarschapssysteem van Rust geleerd:

Elke waarde heeft een eigenaar.
Er kan maar één eigenaar tegelijk zijn.
Wanneer de eigenaar buiten bereik komt, wordt de waarde verwijderd.

Dit systeem voorkomt veelvoorkomende geheugenfouten zonder garbagecollector. Vervolgens bekijken we lenen, zodat je gegevens kunt delen zonder het eigenaarschap over te dragen.

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 “Het ownershipmodel van Rust begrijpen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Het ownershipmodel van Rust begrijpen”, 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 “Het ownershipmodel van Rust begrijpen”?

Krijg inzicht in de basisregels van ownership en move-semantiek, en ontdek hoe deze veelvoorkomende geheugenfouten zoals double-free voorkomen. 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 1 van 3.

Hoe lang duurt de les “Het ownershipmodel van Rust begrijpen”?

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