Programmeringsspråk skiljer sig åt i hur de hanterar minne och upprätthåller regler för minneshantering. Go and Python anställer sophämtare, så utvecklare kan fokusera på att skriva kod. C och C++ ger programmerare ansvar för att hantera minne på en lägre nivå.
Rust behandlar minneshantering olika, med begrepp som det kallar ägande och lån. Den använder en "lånekontroll" för att effektivt upprätthålla minnessäkerhet.
Vad är ägande?
Ägarskap är en funktion och konvention hos Rust som hjälper till att säkerställa minnessäkerheten för program utan en sophämtare. Det är ett annat sätt att tackla problemet med minnesläckor i din kod.
Rust-kompilatorn kontrollerar om ett program följer ägarskapsreglerna vid kompilering. Om programmet följer dessa regler kan det köras. Om det inte gör det, vägrar kompilatorn att producera en körbar fil.
Rust verifierar ägarskapsreglerna med hjälp av låna checker. Lånekontrollen verifierar ägarmodellen och avgör om ett värde i minnet (stack eller hög) är utanför räckvidden eller inte. Om ett värde ligger utanför dess omfattning är det inte tillgängligt för andra delar av programmet om det inte är lånat.
Ägandereglerna
I Rust äger varje variabel värdet den har initierats med, och det kan bara finnas en ägare. När ägaren är utanför räckvidd sjunker värdet. Det är viktigt att förstå detaljerna i ägandereglerna.
Den första ägarregeln är att varje variabel äger sitt initialiserade värde.
låta ägare = Sträng::från en");
De ägare variabel ovan äger strängen ett och, till skillnad från språk som Python och Go, kommer det värdet att tas bort vid omtilldelning av variabel.
Den andra ägarregeln är att två variabler inte kan peka på samma minnesplats; varje värde kan bara ha en ägare.
låta ny_ägare = ägare;
De ny ägare variabeln äger nu värdet lagrat på minnesplatsen för ägare variabel. Om du försöker använda ägare variabel, kommer kompilatorn att få panik, och den kommer att vägra generera en körbar fil.
På de flesta språk som använder sopsamlare kan två variabler peka på samma minnesplats. Här är ett exempel på motsvarande JavaScript-kod:
låta ägare = "ägare";
låta ny_ägare = ägare;
trösta.log (ny_ägare);
Att köra JavaScript-koden ovan fungerar utan fel, och om du gör samma sak i Go eller Python kommer ditt program att fungera utan fel också.
Den tredje äganderegeln är att när en variabel är utanför det deklarerade omfånget, sjunker värdet och minnet avallokeras.
// en variabel i ett separat omfång
{
låta exempel = Sträng::from("Här är ett nytt omfång");
}
skriva ut!("{}", exempel)
Du kan inte komma åt exempel variabel utanför dess räckvidd; Om du försöker göra det kommer kompilatorn att få panik.
Ägande i funktioner
När du skickar ett värde till en funktion som ett argument kan funktionen komma åt den variabeln även om den inte deklarerades i dess omfång:
fnskrivare(värde: Sträng) -> Sträng {
lämna tillbaka värde
}fnhuvud() {
låta x = Sträng::from("Skriver ut ett värde"); // x äger strängvärdet
// ägandet flyttas till skrivarfunktionen här
skriva ut!("{} Den Resultat av utskrift X är att det -:", skrivare (x));
}
Funktionen kan komma åt den variabeln eftersom Rust flyttar äganderätten till den till funktionen vid kompilering.
Du kanske tror att det fortfarande är möjligt att använda variabeln senare i dess ursprungliga omfattning:
fnskrivare(värde: Sträng) -> Sträng {
lämna tillbaka värde
}fnhuvud() {
låta x = Sträng::from("Skriver ut ett värde");
skriva ut!("{} Den Resultat av Utskrift x är att det -:", skrivare (x));
// Försöker använda variabeln efter att äganderätten till dess värde har överförts
println!("{} ska inte vara tillgänglig", x)
}
Men om du försöker detta kommer kompilatorn att få panik och vägra producera en körbar fil:
Rost prioriterar kodåteranvändbarhet
Kodåteranvändbarhet är en viktig praxis, men för att utöva kodåteranvändbarhet måste du förstå Rusts äganderegler.
Rust är ett mycket flexibelt programmeringsspråk. Den tillhandahåller koncept som låna, flytta, kopiera och klona ägande för variabel återanvändning.