Smarte pekere i rust: Hvordan fungerer de?

Minnehåndtering er et av Rusts salgsargumenter, spesielt siden sikkerheten ikke blir kompromittert. Rusts eierskapssystem lar kompilatoren garantere kodesikkerhet og frihet fra minnefeil som hengende pekere og minnelekkasjer.

Rust gir også smarte pekere med ekstra metadata og muligheter utover tradisjonelle pekere. Smarte pekere er nyttige for å takle minnelekkasjer.

Hva er smarte pekere i rust?

Smarte pekere er en av Rusts datatyper som utvider mulighetene til vanlige pekere ved å tilby tilleggsfunksjoner som overbelastede operatører, destruktorer og automatisk minneadministrasjon.

Rust bruker strukturer for å utføre smarte pekere; dermed har smarte pekere også eierskapsmuligheter.

Når du kobler minne som inneholder dynamisk tildelte data med smarte pekere, blir de automatisk deallokert. Smarte pekere gir funksjonalitet for å kontrollere Rusts gjenstands levetid, noe som gjør dem praktiske for å forhindre feil som null-peker-referensing og minnelekkasjer som er populære i andre lavnivåspråk som C og C++.

Fordeler med å bruke smarte pekere

Her er noen fordeler med å bruke smarte pekere:

1. Automatisk minnehåndtering: Smarte pekere gir automatisk minneadministrasjon, inkludert tildeling og deallokering, i motsetning til manuell minnestyring med vanlige pekere.
2. Forbedret sikkerhet: Smarte pekere fremtvinger eierskapssemantikk, og sikrer at bare én eier kan få tilgang til ressurser per gang, og forhindrer datasporing og samtidighetsrelaterte feil.
3. Fleksibilitet: Rust gir flere smarte pekere, hver med sitt sett med eierskapssemantikk for å skrive sikker kode fleksibelt.
4. Ressursforvaltning: Du kan bruke smarte pekere til å administrere andre ressurser som filbehandlere og nettverkskontakter ved å kapsle inn ressursene i en smart peker som gjør det enklere å administrere livssyklusen deres og sikre at de er riktig lukket og frigjort etterpå bruk.
5. Forbedret ytelse: Smarte pekere bidrar til å forbedre ytelsen ved å redusere minnekopiering og -allokeringer – redusert minneavtrykk fra bruk av smarte pekere gir økt ytelse.

Smarte pekere er egnet for mellomstore til store applikasjoner, spesielt i tilfeller der minnehåndtering er kritisk.

Typer smarte pekere

Rust gir flere typer smarte pekere, inkludert Eske, Rc, RefCell, og Mutex.

1. Box Smart Pointer

De Eske Smart Pointer er Rusts enkleste og vanligste smartpeker. De Eske smart pointer hjelper til med å tildele verdier på haugen og skaper en innrammet peker for tilgjengelighet.

De Eske Smart Pointer er nyttig for dynamisk minneallokering når du trenger å sikre at minnet automatisk deallokeres når pekerne er utenfor rekkevidde.

Slik kan du deklarere og bruke en Eske peker:

fnhoved-(){
// ny forekomst av boksens smartpeker 
la x = Eske::ny(5);
println!(x)
}

De Eske type er en del av Rusts preludium, så du slipper å importere typen, i motsetning til andre smarte pekere.

De x variabel er en Eske peker som peker på 5-heltallsverdien. Rust tildeler minnet for verdien på heapen og deallokeres automatisk når variabelen er utenfor scope.

2. Rc Smart Pointer

De Rc (Reference Counted) smart pointer gir funksjonalitet for å skape verdier for delt eierskap. De Rc smarte pekere sporer antall referanser til en verdi og tildeler verdien når den siste referansen er utenfor omfanget.

De Rc smart pointer er nyttig når du trenger å dele eierskapet til en verdi for tilgjengelighet i flere deler av programmet.

Å erklære en Rc smart peker, importerer du Rc struct fra standardbiblioteket, erklærer en ny Rc pekeren med ny funksjon, og klone pekervariabelen med klone variabel.

bruk std:: rc:: Rc;
fnhoved-() {
// ny forekomst av RC-smartpekeren 
la x = Rc:: ny(5);
la y = Rc:: klone(&x);
println!("x = {}, y = {}", x, y);
}

De x variabelen er Rc pekervariabel, og y variabel er en klon med tilgang til verdien i minnet. Referanseantallet er to, og verdien blir deallokert fra minnet når variablene er utenfor omfanget.

3. RefCell Smart Pointer

De RefCell smart pointer gir indre mutabilitet som gjør at uforanderlige og mutbare referanser kan eksistere sammen så lenge det er én mutbar referanse per gitt tid.

De RefCell smart pointer er nyttig når du muterer verdier som eies av mutable referanser.

De Refcell funksjonen er ikke en del av Rusts preludium, så du må importere strukturen fra standardbiblioteket for å bruke smartpekeren.

bruk std:: celle:: RefCell;
fnhoved-(){
// ny forekomst av Refcell smartpeker 
la x = RefCell:: new(5);
la y = x.lån();
la z = x.lån_mut();
println!("y = {}", *y);
println!("z = {}", *z);
} 

De Refcell smart pointer inneholder verdien, og y variabel er den uforanderlige referansen til verdien. De låne_mut funksjonen skaper en mutbar referanse av verdien.

Programmet er trygt hvis det bare er én mutbar referanse om gangen.

4. Mutex Smart Pointer

De Mutex smart pointer gir gjensidige utelukkelser. De Mutex smart pointer er nyttig for å synkronisere tilgang til verdier på tvers av flere tråder i samtidige programmer.

De Mutex smart pointer gir gjensidig ekskludering for å sikre at bare én tråd kan få tilgang til verdien samtidig som datasporing forhindres.

Du må importere Mutex strukturere og opprette en ny forekomst med ny funksjon å bruke Mutex Smart Pointer i rust.

bruk std:: sync:: Mutex;
fnhoved-() {
// ny forekomst av mutex-pekeren 
la teller = Mutex:: ny(0);
 {
lamut num = counter.lock().unwrap();
 *num += 1;
 }
println!("Resultat: {}", *counter.lock().unwrap());
}

De disk variabelen er den nye Mutex forekomst. De hoved- funksjonen får en lås på mutexen med låse metoden for Mutex forekomst. Låsen muliggjør sikker modifisering av tellerens verdi før du frigjør låsen og skriver ut verdien.

De Mutex type garanterer at bare én tråd kan få tilgang til de delte ressursene (i dette tilfellet disk variabel) og endre verdien om gangen. Den gjensidige ekskluderingen sikrer samtidig tilgang til delte ressurser serialisert for å forhindre datasporing og andre samtidighetsproblemer.

Rusts eierskapsmodell garanterer minnesikkerhet

Smarte pekere er en av Rusts tilnærminger til minnesikkerhet og fleksibilitet. Rusts eierskapsmodell sikrer at programmer bruker minnet trygt med lånesjekken ved kompilering.

Lånekontrollen er en avgjørende funksjon i Rusts eierskapsmodell som håndhever strenge regler for minnetilgjengelighet og modifikasjon.