Programmeertalen verschillen in de manier waarop ze met geheugen omgaan en regels voor geheugenbeheer afdwingen. Go en Python gebruiken vuilnismannen, zodat ontwikkelaars zich kunnen concentreren op het schrijven van code. C en C++ geven programmeurs de verantwoordelijkheid om het geheugen op een lager niveau te beheren.
Rust behandelt geheugenbeheer anders, met behulp van concepten die het eigendom en lenen noemt. Het gebruikt een "leencontrole" om de geheugenveiligheid efficiënt af te dwingen.
Wat is eigendom?
Eigendom is een functie en conventie van Rust die helpt om de geheugenveiligheid van programma's zonder afvalverzamelaar te waarborgen. Het is een andere manier van aanpakken het probleem van geheugenlekken in uw code.
De Rust-compiler controleert of een programma tijdens het compileren voldoet aan de eigendomsregels. Als het programma deze regels volgt, kan het worden uitgevoerd. Als dit niet het geval is, weigert de compiler een uitvoerbaar bestand te produceren.
Rust verifieert de eigendomsregels met behulp van de
checker lenen. De leencontrole verifieert het eigendomsmodel en beslist of een waarde in het geheugen (stapel of hoop) valt buiten het bereik of niet. Als een waarde buiten het bereik valt, is deze niet toegankelijk voor andere delen van het programma, tenzij deze is geleend.De eigendomsregels
In Rust bezit elke variabele de waarde waarmee deze is geïnitialiseerd, en er kan maar één eigenaar zijn. Zodra de eigenaar buiten bereik is, wordt de waarde verwijderd. Het is belangrijk om de details van de eigendomsregels te begrijpen.
De eerste eigendomsregel is dat elke variabele zijn geïnitialiseerde waarde bezit.
laten eigenaar = Snaar::from("één");
De baasje variabele hierboven is eigenaar van de string een en, in tegenstelling tot talen zoals Python en Go, wordt die waarde weggelaten bij het opnieuw toewijzen van variabelen.
De tweede eigendomsregel is dat twee variabelen niet naar dezelfde geheugenlocatie kunnen verwijzen; elke waarde kan slechts één eigenaar hebben.
laten nieuwe_eigenaar = eigenaar;
De nieuwe eigenaar variabele is nu eigenaar van de waarde die is opgeslagen op de geheugenlocatie van de baasje variabel. Als u de probeert te gebruiken baasje variabele, zal de compiler in paniek raken en zal hij weigeren een uitvoerbaar bestand te genereren.
In de meeste talen die gebruikmaken van garbage collectors, kunnen twee variabelen naar dezelfde geheugenlocatie verwijzen. Hier is een voorbeeld van een equivalente JavaScript-code:
laten eigenaar = "eigenaar";
laten nieuwe_eigenaar = eigenaar;
troosten.log (nieuwe_eigenaar);
Het uitvoeren van de bovenstaande JavaScript-code werkt zonder fouten, en als u hetzelfde doet in Go of Python, werkt uw programma ook zonder fouten.
De derde eigendomsregel is dat zodra een variabele buiten het gedeclareerde bereik valt, de waarde wordt verwijderd en geheugen wordt vrijgemaakt.
// een variabele in een apart bereik
{
laten voorbeeld = Snaar::from("Hier is een nieuwe scope");
}
afdrukken!("{}", voorbeeld)
U heeft geen toegang tot de voorbeeld variabele buiten het toepassingsgebied; als u dit probeert, raakt de compiler in paniek.
Eigendom in functies
Wanneer u een waarde als argument aan een functie doorgeeft, heeft de functie toegang tot die variabele, ook al is deze niet in zijn bereik gedeclareerd:
fnprinter(waarde: Snaar) -> Snaar {
opbrengst waarde
}fnhoofd() {
laten x = Snaar::from("Drukt een waarde af"); // x is eigenaar van de tekenreekswaarde
// eigendom wordt hier verplaatst naar de printerfunctie
afdrukken!("{} De Resultaat van Printing X is dat het -:", printer (x));
}
De functie heeft toegang tot die variabele omdat Rust het eigendom ervan tijdens het compileren naar de functie verplaatst.
Je zou kunnen denken dat het nog steeds mogelijk is om de variabele later in zijn oorspronkelijke bereik te gebruiken:
fnprinter(waarde: Snaar) -> Snaar {
opbrengst waarde
}fnhoofd() {
laten x = Snaar::from("Drukt een waarde af");
afdrukken!("{} De Resultaat van Printing x is dat het -:", printer (x));
// Proberen de variabele te gebruiken nadat het eigendom van de waarde is overgedragen
println!("{} zou niet toegankelijk moeten zijn", x)
}
Maar als je dit probeert, zal de compiler in paniek raken en weigeren een uitvoerbaar bestand te produceren:
Roest geeft prioriteit aan herbruikbaarheid van code
Herbruikbaarheid van code is een essentiële oefening, maar om herbruikbaarheid van code te oefenen, moet je de eigendomsregels van Rust begrijpen.
Rust is een zeer flexibele programmeertaal. Het biedt concepten zoals lenen, verplaatsen, kopiëren en klonen van eigendom voor variabele herbruikbaarheid.
