Hvordan jobbe med eierskap i rust

I denne artikkelen vil vi utforske rusteierskap og hvordan det fungerer. Eierskap og lånende tilnærming er en relativt ny konstruksjon og turer ny-legevaktere. I denne guiden vil vi forsøke å avmystifisere hvordan eierskap fungerer.

Hva er eierskap?

Tradisjonelt er det to grunnleggende måter å håndtere minner. Den første er søppeloppsamlere; Det brukes hovedsakelig på språk på høyt nivå som abstraherer begrepet minnestyring fra programmereren.

Den andre er "manuell" minnestyring, der programmereren eksplisitt definerer minnebruk. Selv om det gir kontroll, etterlater det mye rom for å skyte deg selv i foten.

Rust tar på seg en alternativ tilnærming som kalles eierskap og lån. Eierskap er en ny "konstruksjon" som definerer en verdi har eieren.

Følgende er eierreglene i rust:

1. Enhver verdi definert i et rustprogram har en eier.
2. En verdi kan ha en eier om gangen.
3. En verdi kan bare leve så lenge eieren er i live. Noe som betyr at eieren ikke har blitt droppet.

For bedre å forstå rustseierskap, la oss diskutere noen få konsepter og eksempler.

omfang

Vi kan definere omfang som et område som en spesifisert verdi lever. Omfanget spiller en viktig rolle i eierskap og lån.

Hver variabel er bundet av omfanget. I dette tilfellet refererer et omfang til en blokk som er omsluttet av et par krøllete seler.

Tenk på følgende eksempelprogram:

fn main ()
// definert i omfanget av hovedfunksjonen
La Long_Life = 100;

// definert i en indre blokk (nytt omfang)
La Short_Life = 10;
Println!("Indre omfang: ", short_life);

// short_life eksisterer ikke i dette omfanget
Println!("Ytre omfang: ", short_life);
Println!("Lang levetid: ", long_life);

fn new_func ()
Println!("Funksjonsomfang: ", long_life);

I det forrige eksempelprogrammet har vi to funksjoner: hovedfunksjonen og New_Func -funksjonen.

Inne i hovedfunksjonen erklærer vi en ny variabel kalt long_life. Vi lager også et nytt omfang og erklærer en ny variabel som heter Short_Life.

Hvis du kjører den forrige koden, vil Rust -kompilatoren fortelle deg at variablene, Short_Life og Long_Life, ikke eksisterer i det omfanget.

Dette er fordi den variable short_life er erklært i et nytt omfang. Når dette omfanget slutter, blir variabelen droppet. Dette betyr at den variable short_life ikke eksisterer utenfor de krøllete seler.

Det samme tilfellet gjelder for lang_livsvariabelen. Det er bare tilgjengelig i hovedfunksjonen. Å prøve å få tilgang til den i en annen funksjon er ikke tillatt.

Skygge

Variabel skygge er et typisk tilfelle. Den refererer til en funksjon der den første variable erklæringen er "overskrevet" eller skygget av en annen.

Ta følgende eksempelkode:

fn main ()
La var1 = 10;
Println!("Før skygge: ", var1);
// etter skygge
La var1 = 100;
Println!("Etter skygge: ", var1);

Her har vi en variabel kalt var1 satt til 10. Deretter skygger vi det ved å erklære variabelen med samme navn og sette den til en ny verdi.

Dette skal skrive ut:

Merk: Ikke forveksle skygge med mutabilitet. Sjekk opplæringen vår om rustmutabilitet for å lære mer.

Overfør eierskap

Rust lar oss overføre eierskapet til verdi ved hjelp av kopierings- eller flytting av operasjoner. Ta følgende eksempelkode:

fn main ()
La var1 = 10;
La var2 = var1;
Println!("var1: ", var1);
Println!("var2: ", var2);

Det forrige eksemplet erklærer en variabel, var1, og tildeler den verdien 10. Vi erklærer også en ny variabel, var2, og tildeler den til var1.

Når dette skjer, vil Rust opprette en ny kopi av verdien og tilordne den til var2. Dette betyr at begge variablene ikke deler verdien, og hver okkuperer sitt eget minneplass.

Hva skjer når vi prøver å utføre den forrige operasjonen på en verdi med en ikke-deterministisk minnestørrelse?

Ta for eksempel en strengtype. Siden det kan vokse eller krympe, er det ingen forhåndsbestemt minnestørrelse. Derfor implementerer den ikke kopienegenskapen:

La str1 = streng :: fra ("Hei");
La str2 = str1;
Println!("str1: ", str1);
Println!("str1: ", str2);

Å kjøre den samme operasjonen tvinger Rust -kompilatoren til å flytte verdien av STR1 til STR2. Siden en verdi bare kan ha en eier av gangen, er variabelen STR1 ikke lenger gyldig. Dette vil føre til at kompilatoren returnerer en feil hvis vi prøver å få tilgang til den:

Konklusjon

En grunn til at rustaceans elsker rustprogrammeringsspråket er eierskap. Det er en ny funksjon som tilbyr mer fleksibilitet og sikkerhet samtidig. Å forstå hvordan det fungerer kan være gunstig for å lage raske og effektive applikasjoner. I tillegg ble eierreglene og konseptene diskutert. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og informasjon.