Waarom lifetimes
Dangling references voorkomen
Waarom lifetimes is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 4. 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 4 lessen.
Referenties moeten geldig blijven
Een referentie leent gegevens die hij niet bezit. Rust moet garanderen dat de gegevens minstens zo lang blijven bestaan als de referentie. Levensduren zijn de manier waarop de compiler dit bijhoudt.
Hun doel: zwevende referenties voorkomen.
Wat is een zwevende referentie?
Een zwevende referentie wijst naar geheugen dat is vrijgegeven. In talen zonder controles veroorzaakt het gebruik ervan crashes of beveiligingsproblemen. Rust weigert zulke code te compileren.
De borrowchecker in actie
Deze code zou een referentie maken naar een waarde die buiten bereik raakt. Rust verwerpt dit tijdens het compileren. Levensduren zijn de regel die daarvoor wordt gebruikt.
fn main() {
let r;
{
let x = 5;
r = &x;
println!("inside: {}", r);
}
// using r here would be a dangling reference
println!("done");
}Scopes bepalen levensduren
De levensduur van een waarde is de periode waarin deze geldig is, meestal zijn scope. Een referentie mag de waarde waarnaar hij wijst niet overleven.
Hier leven zowel x als de referentie in dezelfde scope, dus is alles in orde.
fn main() {
let x = 5;
let r = &x;
println!("x is {}, r is {}", x, r);
}Referenties retourneren
Een functie die een referentie retourneert, moet er een retourneren die geldig blijft voor de aanroeper. Je kunt geen referentie naar een lokale variabele retourneren, omdat die verdwijnt wanneer de functie eindigt.
Een lening van een invoer retourneren
Wat je wel kunt doen, is een referentie retourneren die van een invoer leent. Het resultaat blijft geldig zolang die invoer geldig is. Dit is precies wat levensduurannotaties beschrijven.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[..i];
}
}
s
}
fn main() {
let sentence = String::from("hello world");
println!("{}", first_word(&sentence));
}Levensduren bestaan alleen tijdens het compileren
Levensduren zijn puur een concept tijdens het compileren. Ze brengen geen runtime-kosten met zich mee en bestaan alleen om de borrowchecker de geheugenveiligheid te laten controleren.
Eigenaarschap en levensduren samen
Eigenaarschap bepaalt wie een waarde vrijgeeft; levensduren bepalen hoelang leningen ervan mogen bestaan. Samen zorgen ze ervoor dat Rust veiligheid zonder garbagecollector kan garanderen.
fn main() {
let data = vec![1, 2, 3];
let view = &data[0..2];
println!("{:?}", view);
// data still owns the vector; view just borrows part of it
println!("{:?}", data);
}Waarom namen in signatures voorkomen
Wanneer een functie meerdere referenties aanneemt, kan de compiler soms niet bepalen hoe hun levensduren zich tot elkaar verhouden. Je voegt dan levensduurannotaties toe om die relaties te verduidelijken.
De volgende les behandelt die syntaxis.
Het resultaat
Dankzij levensduren kan een hele categorie bugs — gebruik-na-vrijgave, zwevende pointers en ongeldige iterators — eenvoudigweg niet compileren. Je krijgt de snelheid van C met geheugenveiligheid.
Mentaal model
Zie een levensduur als een label voor de periode waarin gegevens bestaan. Een referentie draagt de beperking: ik ben alleen geldig zolang mijn bron bestaat. De borrowchecker dwingt dit af.
Korte controle
Test je begrip van de reden waarom levensduren bestaan.
Samenvatting
Je hebt geleerd waarom levensduren bestaan:
- Referenties mogen de gegevens die ze lenen niet overleven
- Levensduren voorkomen zwevende referenties tijdens het compileren
- Ze bestaan alleen tijdens het compileren en hebben geen runtime-kosten
- Ze werken samen met eigenaarschap voor geheugenveiligheid zonder GC
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
Veelgestelde vragen
Is de les “Waarom lifetimes” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Waarom lifetimes”, 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 4 lessen.
Wat leer ik in “Waarom lifetimes”?
Dangling references 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 4.
Hoe lang duurt de les “Waarom lifetimes”?
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
- Waarom lifetimes
- Lifetime-annotaties
- Lifetimes in structs
- Elisionregels