Rust gebruikt een leencontrole om zijn eigendomsregels af te dwingen en ervoor te zorgen dat programma's geheugenveilig zijn. De eigendomsregels bepalen hoe Rust het geheugen over de stapel en heap beheert.

Terwijl u Rust-programma's schrijft, moet u variabelen gebruiken zonder het eigendom van de bijbehorende waarde te wijzigen. Rust biedt een robuust leenmechanisme om flexibiliteit en hergebruik van code aan te moedigen.

Wat is lenen in roest?

Lenen is toegang krijgen tot de waarde van een variabele zonder eigenaar worden van de variabele door te verwijzen naar de eigenaar. De leencontrole zorgt ervoor dat de referentie geldig is en dat de gegevens niet worden verwijderd met behulp van een constructie die levensduur wordt genoemd.

Een levensduur is hoe lang een variabele bestaat. Levens beginnen bij het creëren van variabelen en eindigen bij het vernietigen van variabelen. U kunt het eigendom van een variabele lenen, en wanneer de geleende referentie buiten het bereik valt, keert het eigendom terug naar de eigenaarvariabele. Lenen is een beetje zoals de

instagram viewer
verwijzingen die u vindt in talen als C++ en Go. Maar de Rust-compiler gebruikt de leencontrole om ervoor te zorgen dat programma's geheugenveilig zijn.

Een voorbeeld van lenen in Rust

U kunt het eigendom van een variabele lenen door naar de eigenaar te verwijzen met het en-teken (&).

fnhoofd() {
laten x = Snaar::from("hallo"); // x is eigenaar van "hallo"
laten y = &x; // y verwijst naar x, leent "hallo"
println!("{}", x); 
println!("{}", j)
}

Zonder te lenen door te verwijzen, zou het programma in paniek raken. Het zou in strijd zijn met de eigendomsregel dat een waarde één eigenaar kan hebben en dat twee variabelen niet naar dezelfde geheugenlocatie kunnen verwijzen. Lenen kan erg handig zijn in functies. Hier is een voorbeeld van lenen in een functie, om het eigendom te behouden terwijl andere functies worden aangeroepen die lokale variabelen als argumenten gebruiken.

fnprint_even(vector: &Vec<i32>) {
voor waarden in vector {
als waarden % 2 == 0 {
println!("{}", waarden);
 }
 }
}

De print_even functie verwijst naar een vector van 32-bits gehele getallen als argument. Het drukt vervolgens regels met waarden af ​​die veelvouden zijn van twee in de vector met behulp van een for-lus en de println! macro.

fnhoofd() {
laten number_vector = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 print_even(&nummer_vector); // eigendom is geleend, niet verplaatst
println!("De hoofdfunctie behoudt het eigendom van de getalvector{:?}", number_vector)
}

De hoofdfunctie declareert de variabele number_vector en wijst er een vector van 32-bits gehele getallen aan toe. Vervolgens roept het de functie print_even aan en geeft het een verwijzing door aan de nummer_vector variabele met het ampersand-symbool.

De hoofdfunctie behoudt het eigendom van de nummer_vector variabele kan het de waarde op zijn geheugenlocatie blijven gebruiken.

Referenties lenen en muteren

Functies kunnen geleende variabelen ook wijzigen met behulp van veranderlijke verwijzingen ernaar, voordat ze weer eigendom worden.

In tegenstelling tot reguliere variabelen die kunnen worden ingesteld op mutable met het sleutelwoord mut, moet u mutable references vooraf laten gaan door het ampersand-symbool.

Voordat u veranderlijke verwijzingen maakt, moet de variabele die u wilt wijzigen veranderbaar zijn.

fnremove_value(vector: &mutVec<i32>) -> &Vec<i32> {
 vectr.verwijder(4);
opbrengst vector
}

De remove_value functie neemt de referentie op van een veranderlijke vector van 32-bits gehele getallen. Het retourneert een vector van 32-bits gehele getallen na het verwijderen van de waarde van de vector in de vierde index.

fnhoofd() {
latenmut nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 remove_value(&mut nummers); // veranderlijke verwijzing hier
println!("{:?}", getallen); 
}

De functie wijzigt de nums vector door remove_value aan te roepen en de veranderlijke verwijzing van een vector als argument door te geven. Bij het afdrukken van de vector bestaat de voorafgaande vierde index van de vector niet.

Merk op dat het argument een verwijzing is naar een veranderlijke vector.

Het is belangrijk om eigendom en lenen te begrijpen

U moet eigendom en lenen begrijpen om efficiënte, geheugenveilige Rust-code te schrijven die wordt gecompileerd en uitgevoerd. Als uw code niet aan de eigendomsregels voldoet, zal de leencontrole deze detecteren. U moet uw programma geheugenveilig maken zodat Rust het kan compileren.

De leenchecker is vervelend als je nieuw bent bij Rust. Maar naarmate je meer Rust-code schrijft, zul je eraan wennen en ervaring opdoen met het schrijven van geheugenveilige Rust-code.