Rust bruker en lånekontroll for å håndheve eierskapsreglene og sikre at programmene er minnesikre. Eierskapsreglene dikterer hvordan Rust styrer hukommelsen over stabelen og haugen.
Når du skriver Rust-programmer, må du bruke variabler uten å endre eierskapet til den tilknyttede verdien. Rust gir en robust lånemekanisme for å oppmuntre til fleksibilitet og gjenbruk av kode.
Hva er å låne i rust?
Lån er å få tilgang til verdien av en variabel uten tar eierskap til variabelen ved å referere til eieren. Lånekontrollen sørger for at referansen er gyldig, og at dataene ikke slettes ved å bruke en konstruksjon som kalles levetider.
En levetid er hvor lenge en variabel eksisterer. Levetider starter med variabel opprettelse og slutter med variabel ødeleggelse. Du kan låne eierskapet til en variabel, og når den lånte referansen er utenfor omfanget, går eierskapet tilbake til eiervariabelen. Låne er litt som pekere du finner på språk som C++ og Go. Men Rust-kompilatoren bruker lånekontrollen for å sikre at programmene er minnesikre.
Et eksempel på lån i rust
Du kan låne eierskapet til en variabel ved å referere til eieren ved å bruke og-tegnet (&).
fnhoved-() {
la x = String::fra("hei"); // x eier "hei"
la y = &x; // y referanser x, låner "hei"
println!("{}", x);
println!("{}", y)
}
Uten å låne ved å referere, ville programmet få panikk. Det ville bryte eierskapsregelen om at en verdi kan ha én eier, og to variabler kan ikke peke til samme minneplassering. Lån kan være svært nyttig i funksjoner. Her er et eksempel på å låne i en funksjon, for å beholde eierskapet mens du kaller andre funksjoner som tar lokale variabler som argumenter.
fnprint_even(vectr: &Vec<i32>) {
til verdier i vectr {
hvis verdier % 2 == 0 {
println!("{}", verdier);
}
}
}
De print_even funksjon refererer til en vektor med 32-bits heltall som argument. Den skriver deretter ut linjer med verdier som er multipler av to i vektoren ved å bruke en for-løkke og println! makro.
fnhoved-() {
la tall_vektor = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&tall_vektor); // eierskap er lånt, ikke flyttet
println!("Hovedfunksjonen beholder eierskapet til tallvektoren{:?}", tall_vektor)
}
Hovedfunksjonen erklærer tall_vektor-variabelen og tildeler en vektor med 32-bits heltall til den. Den kaller deretter print_even-funksjonen og sender den en referanse til tall_vektor variabel ved å bruke og-tegnet.
Hovedfunksjonen beholder eierskapet til tall_vektor variabel kan den fortsette å bruke verdien på minneplasseringen.
Låne og muterende referanser
Funksjoner kan også endre lånte variabler ved å bruke mutbare referanser til dem før de returnerer eierskap.
Men i motsetning til vanlige variabler som kan settes til mutable ved hjelp av mut-nøkkelordet, må du prefiksere mutable referanser med og-tegnet.
Før du lager mutbare referanser, må variabelen du ønsker å endre være mutbar.
fnfjerne_verdi(vectr: &mutVec<i32>) -> &Vec<i32> {
vectr.remove(4);
komme tilbake vectr
}
De fjerne_verdi funksjonen tar inn referansen til en mutbar vektor med 32-biters heltall. Den returnerer en vektor med 32-bits heltall etter å ha fjernet verdien av vektoren i den fjerde indeksen.
fnhoved-() {
lamut tall = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
fjern_verdi(&mut nums); // foranderlig referanse her
println!("{:?}", nums);
}
Funksjonen endrer nums vektor ved å kalle remove_value og sende den mutbare referansen til en vektor som et argument. Ved utskrift av vektoren eksisterer ikke den forrige fjerde indeksen til vektoren.
Legg merke til at argumentet er en referanse til en mutbar vektor.
Det er viktig å forstå eierskap og lån
Du må forstå eierskap og lån for å skrive effektiv, minnesikker rustkode som kompilerer og kjører. Hvis koden din ikke følger eierskapsreglene, vil lånekontrollen oppdage den. Du må gjøre programmet minnesikkert for at Rust kan kompilere det.
Lånekontrollen er irriterende når du er ny på Rust. Men når du skriver mer rustkode, vil du bli vant til det og få erfaring med å skrive minnesikker rustkode.