Programmeringsspråk er forskjellige i hvordan de håndterer minne og håndhever regler for minneadministrasjon. Go og Python ansetter søppelsamlere, slik at utviklere kan fokusere på å skrive kode. C og C++ gir programmerere ansvar for å administrere minne på et lavere nivå.

Rust behandler minnehåndtering annerledes ved å bruke konsepter det kaller eierskap og lån. Den bruker en "lånesjekker" for å håndheve minnesikkerheten effektivt.

Hva er eierskap?

Eierskap er en funksjon og konvensjon av Rust som bidrar til å sikre minnesikkerheten til programmer uten en søppeloppsamler. Det er en annen måte å takle på problemet med minnelekkasjer i koden din.

Rust-kompilatoren sjekker om et program overholder eierskapsreglene på kompileringstidspunktet. Hvis programmet følger disse reglene, kan det kjøres. Hvis den ikke gjør det, nekter kompilatoren å produsere en kjørbar fil.

Rust verifiserer eierskapsreglene ved å bruke låne brikke. Lånekontrollen verifiserer eierskapsmodellen og bestemmer om en verdi i minnet (

instagram viewer
stabel eller haug) er utenfor omfanget eller ikke. Hvis en verdi er utenfor omfanget, er den ikke tilgjengelig for andre deler av programmet med mindre den er lånt.

Eierskapsreglene

I Rust eier hver variabel verdien den er initialisert med, og det kan bare være én eier. Når eieren er utenfor omfanget, faller verdien. Det er viktig å forstå detaljene i eierskapsreglene.

Den første eierskapsregelen er at hver variabel eier sin initialiserte verdi.

la eier = String::fra("en");

De Eieren variabelen ovenfor eier strengen en og, i motsetning til språk som Python og Go, vil denne verdien bli droppet ved variabel omtilordning.

Den andre eierskapsregelen er at to variabler ikke kan peke til samme minneplassering; hver verdi kan bare ha én eier.

la ny_eier = eier;

De ny_eier variabelen eier nå verdien som er lagret på minnestedet til Eieren variabel. Hvis du prøver å bruke Eieren variabel, vil kompilatoren få panikk, og den vil nekte å generere en kjørbar fil.

På de fleste språk som bruker søppelsamlere, kan to variabler peke til samme minneplassering. Her er et eksempel på tilsvarende JavaScript-kode:

la eier = "eier";
la ny_eier = eier;
konsoll.log (ny_eier);

Å kjøre JavaScript-koden ovenfor fungerer uten feil, og hvis du gjør det samme i Go eller Python, vil programmet også fungere uten feil.

Den tredje eierskapsregelen er at når en variabel er utenfor det deklarerte omfanget, blir verdien droppet, og minnet blir deallokert.

// en variabel i et eget omfang
{
la eksempel = String::from("Her er et nytt omfang");
}

skrive ut!("{}", eksempel)

Du får ikke tilgang til eksempel variabel utenfor omfanget; prøver å gjøre det vil føre til at kompilatoren får panikk.

Eierskap i funksjoner

Når du sender en verdi til en funksjon som et argument, kan funksjonen få tilgang til den variabelen selv om den ikke ble deklarert i sitt omfang:

fnskriver(verdi: String) -> String {
komme tilbake verdi
}

fnhoved-() {
la x = String::from("Skriver ut en verdi"); // x eier strengverdien

// eierskap flyttes til skriverfunksjonen her
skrive ut!("{} Den Resultat av utskrift X er at det -:", skriver (x));
}

Funksjonen kan få tilgang til den variabelen fordi Rust flytter eierskapet til den til funksjonen på kompileringstidspunktet.

Du tror kanskje det fortsatt er mulig å bruke variabelen senere i det opprinnelige omfanget:

fnskriver(verdi: String) -> String {
komme tilbake verdi
}

fnhoved-() {
la x = String::from("Skriver ut en verdi");
skrive ut!("{} Den Resultat av Utskrift x er at det -:", skriver (x));

// Prøver å bruke variabelen etter at eierskapet til verdien er overført
println!("{} skal ikke være tilgjengelig", x)
}

Men hvis du prøver dette, vil kompilatoren få panikk og nekte å produsere en kjørbar fil:

Rust prioriterer gjenbruk av kode

Gjenbruk av kode er en viktig praksis, men for å praktisere gjenbruk av kode må du forstå Rusts eierskapsregler.

Rust er et veldig fleksibelt programmeringsspråk. Det gir konsepter som lån, flytting, kopiering og kloning av eierskap for variabel gjenbruk.