A Rust egy kölcsön-ellenőrzőt használ tulajdonosi szabályainak érvényesítésére és a programok memóriabiztonságának biztosítására. A tulajdonosi szabályok határozzák meg, hogy Rust hogyan kezeli a memóriát a verem és a kupac felett.

A Rust programok írásakor változókat kell használnia anélkül, hogy megváltoztatná a társított érték tulajdonjogát. A Rust robusztus kölcsönzési mechanizmust biztosít a rugalmasság és a kód újrafelhasználásának elősegítése érdekében.

Mi az a kölcsönfelvétel Rozsdában?

A kölcsönzés egy változó értékének elérése anélkül átveszi a változó tulajdonjogát a tulajdonosra hivatkozva. A kölcsönzés-ellenőrző biztosítja, hogy a hivatkozás érvényes legyen, és az adatok ne kerüljenek eldobásra az élettartamok nevű konstrukcióval.

Az élettartam az, hogy mennyi ideig létezik egy változó. Az élettartam a változó létrehozásával kezdődik és a változó megsemmisítésével ér véget. Kölcsönözheti egy változó tulajdonjogát, és ha a kölcsönzött hivatkozás kívül esik a hatókörön, a tulajdonjog visszatér a tulajdonos változóhoz. A kölcsönzés egy kicsit olyan, mint a

instagram viewer
mutatók, amelyeket olyan nyelveken találhat, mint a C++ és a Go. De a Rust fordító a kölcsönellenőrzőt használja, hogy biztosítsa a programok memóriabiztonságát.

Példa a kölcsönzésre Rozsdában

Kölcsönözheti egy változó tulajdonjogát, ha a tulajdonosra az „és” (&) jellel hivatkozik.

fnfő-() {
hagyja x = Húr::from("hello"); // x tulajdonosa a "hello"
hagyja y = &x; // y x-re hivatkozik, kölcsönzi a "hello"-t
println!("{}", x);
println!("{}", y)
}

Hivatkozással történő kölcsönzés nélkül a program pánikba esne. Sértené a tulajdonjogi szabályt, miszerint egy értéknek egy tulajdonosa lehet, és két változó nem mutathat ugyanarra a memóriahelyre. A kölcsönzés nagyon hasznos lehet a funkciókban. Íme egy példa egy függvény kölcsönzésére, amellyel megtarthatja a tulajdonjogot, miközben olyan függvényeket hív meg, amelyek helyi változókat vesznek argumentumként.

fnprint_even(vektor: &Vec<i32>) {
számára értékeket ban ben vectr {
ha értékek % 2 == 0 {
println!("{}", értékek);
}
}
}

Az print_even függvény argumentumaként egy 32 bites egész számok vektorára hivatkozik. Ezután olyan értékek sorait nyomtatja ki, amelyek a vektorban kettő többszörösei a for-hurok és a println! makró.

fnfő-() {
hagyja szám_vektor = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&számvektor); // a tulajdonjog kölcsönzött, nem költözik
println!("A fő függvény megtartja a számvektor tulajdonjogát{:?}", számvektor)
}

A főfüggvény deklarálja a number_vector változót, és hozzárendel egy 32 bites egész számokból álló vektort. Ezután meghívja a print_even függvényt, és hivatkozást ad át neki szám_vektor változó az „és” jellel.

A fő funkció megtartja a tulajdonjogot a szám_vektor változó továbbra is használhatja az értéket a memóriahelyén.

Hivatkozások kölcsönzése és mutációja

A függvények a tulajdonjog visszaadása előtt módosíthatják a kölcsönzött változókat a rájuk mutató változó hivatkozások segítségével.

Ellentétben azonban a szokásos változókkal, amelyek a mut kulcsszóval változtathatóvá állíthatók be, a mutálható hivatkozásokat "és" jellel kell előtagolni.

Módosítható hivatkozások létrehozása előtt a módosítani kívánt változónak módosíthatónak kell lennie.

fnRemove_value(vektor: &mutVec<i32>) -> &Vec<i32> {
vectr.remove(4);
Visszatérés vectr
}

Az Remove_value függvény egy 32 bites egész számokból álló mutálható vektor referenciáját veszi fel. 32 bites egész számokból álló vektort ad vissza, miután eltávolította a vektor értékét a negyedik indexben.

fnfő-() {
hagyjamut számok = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
remove_value(&mut számok); // itt változtatható hivatkozás
println!("{:?}", számok);
}

A függvény módosítja a számok vektort úgy, hogy meghívja az remove_value függvényt, és argumentumként átadja egy vektor módosítható hivatkozását. A vektor nyomtatásakor a vektor előző negyedik indexe nem létezik.

Figyeljük meg, hogy az argumentum egy változtatható vektorra való hivatkozás.

Fontos megérteni a tulajdonjogot és a hitelfelvételt

Meg kell értenie a tulajdonjogot és a kölcsönzést, hogy hatékony, memóriabiztos Rust kódot írhasson, amely lefordítja és lefut. Ha kódja nem követi a tulajdonosi szabályokat, a kölcsönzés-ellenőrző észleli. A programot memóriabiztossá kell tennie, hogy a Rust le tudja fordítani.

A kölcsön-ellenőrző bosszantó, ha új vagy a Rustban. De ahogy több Rust kódot ír, megszokja, és tapasztalatot szerez a memóriabiztos Rust kód írásában.