Slimme aanwijzingen in roest: hoe werken ze?

Geheugenbeheer is een van de verkoopargumenten van Rust, vooral omdat de veiligheid niet in het gedrang komt. Dankzij het eigendomssysteem van Rust kan de compiler codeveiligheid garanderen en vrij zijn van geheugenfouten zoals bungelende aanwijzers en geheugenlekken.

Rust biedt ook slimme aanwijzers met aanvullende metadata en mogelijkheden die verder gaan dan traditionele aanwijzers. Slimme aanwijzers zijn handig om geheugenlekken aan te pakken.

Wat zijn slimme aanwijzers in roest?

Slimme aanwijzers zijn er een van De gegevenstypen van Rust dat breidt de mogelijkheden van reguliere pointers uit door extra functionaliteiten aan te bieden, zoals overbelaste operators, destructors en automatisch geheugenbeheer.

Rust gebruikt structs om slimme pointers uit te voeren; dus slimme pointers hebben ook eigendomsmogelijkheden.

Wanneer u geheugen koppelt dat dynamisch toegewezen gegevens bevat met slimme aanwijzers, worden ze automatisch ongedaan gemaakt. Slimme aanwijzers bieden functionaliteit voor het besturen van de

De levensduur van het object van Rust, waardoor ze handig zijn voor het voorkomen van fouten zoals null pointer dereferentie en geheugenlekken die populair zijn in andere low-level talen zoals C en C++.

Voordelen van het gebruik van slimme aanwijzers

Hier zijn enkele voordelen van het gebruik van slimme aanwijzers:

1. Automatisch geheugenbeheer: Slimme pointers zorgen voor automatisch geheugenbeheer, inclusief toewijzing en deallocatie, in tegenstelling tot handmatig geheugenbeheer met reguliere pointers.
2. Verbeterde veiligheid: Slimme aanwijzers dwingen eigendomsemantiek af, zodat slechts één eigenaar per keer toegang heeft tot bronnen, waardoor gegevenssporen en concurrency-gerelateerde bugs worden voorkomen.
3. Flexibiliteit: Rust biedt meerdere slimme aanwijzers, elk met zijn set van eigendom semantiek voor het flexibel schrijven van veilige code.
4. Middelenbeheer: U kunt slimme aanwijzers gebruiken om andere bronnen zoals bestandshandlers en netwerksockets te beheren door de bronnen in te kapselen binnen een slimme aanwijzer die het gemakkelijker maakt om hun levenscyclus te beheren en ervoor te zorgen dat ze correct worden gesloten en daarna worden vrijgegeven gebruik.
5. Verbeterde prestatie: Slimme aanwijzers helpen de prestaties te verbeteren door het kopiëren en toewijzen van geheugen te verminderen. Minder geheugengebruik door het gebruik van slimme aanwijzers resulteert in betere prestaties.

Slimme aanwijzers zijn geschikt voor middelgrote tot grote toepassingen, vooral in gevallen waarin geheugenbeheer van cruciaal belang is.

Soorten slimme aanwijzers

Rust biedt meerdere soorten slimme aanwijzers, waaronder Doos, Rc, RefCel, En Mutex.

1. De Box Smart Pointer

De Doos Smart Pointer is Rust's eenvoudigste en meest voorkomende slimme pointer. De Doos slimme aanwijzer helpt bij het toewijzen van waarden op de heap en creëert een aanwijzer in een kader voor toegankelijkheid.

De Doos Smart Pointer is handig voor dynamische geheugentoewijzing wanneer u ervoor moet zorgen dat het geheugen automatisch wordt vrijgemaakt wanneer de aanwijzers buiten bereik zijn.

Hier leest u hoe u a kunt declareren en gebruiken Doos wijzer:

fnvoornaamst(){
// nieuw exemplaar van de box smart pointer 
laten x= Doos::nieuw(5);
println!(X)
}

De Doos type maakt deel uit van Rust's prelude, dus je hoeft het type niet te importeren, in tegenstelling tot andere slimme aanwijzers.

De X variabele is een Doos aanwijzer die naar de 5 integer-waarde wijst. Rust wijst het geheugen toe voor de waarde op de heap en maakt de toewijzing automatisch ongedaan wanneer de variabele buiten het bereik valt.

2. De Rc slimme aanwijzer

De Rc (Reference Counted) slimme aanwijzer biedt functionaliteit voor het creëren van waarden van gedeeld eigendom. De Rc slimme pointers houden het aantal verwijzingen naar een waarde bij en maken de waarde ongedaan wanneer de laatste verwijzing buiten het bereik valt.

De Rc slimme aanwijzer is handig wanneer u het eigendom van een waarde voor toegankelijkheid in meerdere delen van uw programma moet delen.

Aangifte doen van een Rc slimme aanwijzer, importeert u de Rc struct uit de standaardbibliotheek, declareer een nieuw Rc aanwijzer met de nieuw functie en kloon de pointervariabele met de kloon variabel.

gebruik standaard:: rc:: rc;
fnvoornaamst() {
// nieuw exemplaar van de RC slimme aanwijzer 
laten x = Rc:: nieuw(5);
laten y = Rc:: kloon(&x);
println!("x = {}, y = {}", x, y);
}

De X variabele is de Rc pointer variabele, en de j variabele is een kloon met toegang tot de waarde in het geheugen. Het aantal referenties is twee en de waarde wordt uit het geheugen verwijderd wanneer de variabelen buiten het bereik vallen.

3. De RefCell slimme aanwijzer

De RefCel slimme aanwijzer biedt interne veranderlijkheid waardoor onveranderlijke en veranderlijke referenties naast elkaar kunnen bestaan, zolang er maar één veranderlijke referentie per bepaalde tijd is.

De RefCel slimme aanwijzer is handig bij het muteren van waarden die eigendom zijn van veranderlijke referenties.

De Refcel functie maakt geen deel uit van Rust's prelude, dus je moet de struct uit de standaardbibliotheek importeren om de slimme aanwijzer te gebruiken.

gebruik standaard:: cel:: RefCell;
fnvoornaamst(){
// nieuw exemplaar van de Refcell slimme aanwijzer 
laten x = RefCell:: nieuw(5);
laten y = x.lenen();
laten z = x.lenen_mut();
println!("j = {}", *y);
println!("z = {}", *z);
} 

De Refcel slimme aanwijzer bevat de waarde en de j variabele is de onveranderlijke verwijzing naar de waarde. De lenen_mut functie creëert een veranderlijke referentie van de waarde.

Het programma is veilig als er slechts één veranderlijke referentie tegelijk is.

4. De Mutex slimme aanwijzer

De Mutex slimme aanwijzer zorgt voor wederzijdse uitsluitingen. De Mutex slimme aanwijzer is handig voor het synchroniseren van toegang tot waarden over meerdere threads in gelijktijdige programma's.

De Mutex slimme aanwijzer biedt wederzijdse uitsluiting om ervoor te zorgen dat slechts één thread toegang heeft tot de waarde, terwijl gegevenssporen worden voorkomen.

U moet de Mutex struct en maak een nieuwe instantie aan met de nieuw functie te gebruiken Mutex Slimme aanwijzer in roest.

gebruik std:: synchronisatie:: Mutex;
fnvoornaamst() {
// nieuw exemplaar van de mutex-aanwijzer 
laten teller = Mutex:: nieuw(0);
 {
latenmuts num = counter.lock().unwrap();
 *getal += 1;
 }
println!("Resultaat: {}", *counter.lock().uitpakken());
}

De balie variabele is het nieuwe Mutex voorbeeld. De voornaamst functie krijgt een slot op de mutex met de slot methode van de Mutex voorbeeld. De vergrendeling maakt een veilige wijziging van de waarde van de teller mogelijk voordat de vergrendeling wordt opgeheven en de waarde wordt afgedrukt.

De Mutex type garandeert dat slechts één thread toegang heeft tot de gedeelde bronnen (in dit geval de balie variabele) en wijzig de waarde per keer. De wederzijdse uitsluiting zorgt ervoor dat gelijktijdige toegang tot gedeelde bronnen wordt geserialiseerd om gegevenssporen en andere gelijktijdigheidsproblemen te voorkomen.

Het eigendomsmodel van Rust garandeert geheugenveiligheid

Slimme aanwijzers zijn een van Rust's benaderingen van geheugenveiligheid en -flexibiliteit. Het eigendomsmodel van Rust zorgt ervoor dat programma's het geheugen tijdens het compileren veilig gebruiken met de leencontrole.

De leencontrole is een cruciaal kenmerk van het eigendomsmodel van Rust dat strikte regels afdwingt voor de toegankelijkheid en wijziging van het geheugen.