A programozási nyelvek abban különböznek, hogy hogyan kezelik a memóriát és hogyan kényszerítik ki a memóriakezelési szabályokat. A Go és a Python szemétgyűjtőket alkalmaz, így a fejlesztők a kódírásra koncentrálhatnak. A C és C++ a programozóknak felelősséget ad a memória alacsonyabb szintű kezeléséért.
A Rust másként kezeli a memóriakezelést, az általa tulajdonjognak és kölcsönzésnek nevezett fogalmakat használva. „Kölcsönellenőrzőt” használ a memóriabiztonság hatékony érvényesítésére.
Mi az a tulajdonjog?
A tulajdonjog a Rust olyan funkciója és egyezménye, amely segít a szemétgyűjtő nélküli programok memóriabiztonságának biztosításában. Ez egy másik módja a kezelésnek a memóriaszivárgás problémája a kódodban.
A Rust fordító ellenőrzi, hogy egy program megfelel-e a tulajdonosi szabályoknak fordításkor. Ha a program betartja ezeket a szabályokat, akkor futhat. Ha nem, a fordító megtagadja a végrehajtható fájl létrehozását.
A Rust a tulajdonosi szabályokat a kölcsönellenőrzőt. A kölcsön-ellenőrző ellenőrzi a tulajdonosi modellt, és eldönti, hogy van-e érték a memóriában (
verem vagy halom) hatályon kívül esik-e vagy sem. Ha egy érték kívül esik a hatókörén, akkor a program más részei nem férhetnek hozzá, hacsak nem kölcsönzik.A Tulajdonosi Szabályzat
A Rustban minden változónak az az értéke van, amellyel inicializálva van, és csak egy tulajdonos lehet. Ha a tulajdonos kívül esik a hatókörön, az érték elvész. Fontos megérteni a tulajdonosi szabályok részleteit.
Az első tulajdonosi szabály az, hogy minden változónak saját inicializált értéke van.
hagyja tulajdonos = Húr::from("egy");
Az tulajdonos a fenti változó birtokolja a karakterláncot egy és az olyan nyelvekkel ellentétben, mint a Python és a Go, ez az érték elvész a változó-újra hozzárendeléskor.
A második tulajdonosi szabály az, hogy két változó nem mutathat ugyanarra a memóriahelyre; minden értéknek csak egy tulajdonosa lehet.
hagyja new_owner = tulajdonos;
Az új tulajdonos változó birtokában van a memóriahelyén tárolt érték tulajdonos változó. Ha megpróbálja használni a tulajdonos változó esetén a fordító pánikba esik, és megtagadja a végrehajtható fájl létrehozását.
A legtöbb szemétgyűjtőt használó nyelvben két változó mutathat ugyanarra a memóriahelyre. Íme egy példa egyenértékű JavaScript kódra:
hagyja tulajdonos = "tulajdonos";
hagyja new_owner = tulajdonos;
konzol.log (új_tulajdonos);
A fenti JavaScript-kód futtatása hiba nélkül működik, és ha ugyanezt teszi a Go vagy a Python programban, akkor a program is hiba nélkül fog működni.
A harmadik tulajdonosi szabály az, hogy ha egy változó a deklarált hatókörön kívül esik, az érték elvész, és a memória felszabadításra kerül.
// egy változó külön hatókörben
{
hagyja példa = Húr::from("Itt egy új hatókör");
}
nyomtatás!("{}", példa)
Nem férhet hozzá a példa hatályán kívül eső változó; ennek megkísérlése pánikba ejti a fordítót.
Tulajdonjog a Functions-ban
Ha argumentumként ad át egy értéket egy függvénynek, a függvény hozzáférhet ahhoz a változóhoz, még akkor is, ha nem volt deklarálva a hatókörében:
fnnyomtató(érték: Húr) -> Húr {
Visszatérés érték
}fnfő-() {
hagyja x = Húr::from("Értéket nyomtat"); // x birtokolja a karakterlánc értékét
// a tulajdonjog átkerült a nyomtató funkcióhoz
nyomtatás!("{} Az Eredmény a Nyomtatás X az, hogy -:", nyomtató (x));
}
A függvény hozzáférhet ehhez a változóhoz, mert a Rust fordításkor átadja a tulajdonjogát a függvénynek.
Azt gondolhatja, hogy továbbra is lehetséges a változó későbbi használata az eredeti hatókörében:
fnnyomtató(érték: Húr) -> Húr {
Visszatérés érték
}fnfő-() {
hagyja x = Húr::from("Értéket nyomtat");
nyomtatás!("{} Az Eredmény a Nyomtatás x az, hogy -:", nyomtató (x));
// Megpróbálja használni a változót, miután az értékének tulajdonjogát átadták
println!("{} nem lehet hozzáférhető", x)
}
De ha ezt megpróbálja, a fordító pánikba esik, és nem hajlandó végrehajtani:
A rozsda a kód újrafelhasználását helyezi előtérbe
A kód újrafelhasználása alapvető gyakorlat, de a kód újrafelhasználásának gyakorlásához meg kell értenie a Rust tulajdonjogi szabályait.
A Rust egy nagyon rugalmas programozási nyelv. Olyan fogalmakat biztosít, mint a kölcsönzés, az áthelyezés, a másolás és a tulajdonjog klónozása a változó újrafelhasználhatóság érdekében.