Smarta pekare har ytterligare fördelar jämfört med vanliga pekare. Här är allt du behöver veta om smarta pekare i Rust.
Minneshantering är en av Rusts försäljningsargument, särskilt eftersom säkerheten inte äventyras. Rusts ägarsystem tillåter kompilatorn att garantera kodsäkerhet och frihet från minnesfel som dinglande pekare och minnesläckor.
Rust ger också smarta pekare med ytterligare metadata och funktioner utöver traditionella pekare. Smarta pekare är praktiska för att hantera minnesläckor.
Vad är smarta pekare i rost?
Smarta pekare är en av Rusts datatyper som utökar kapaciteten hos vanliga pekare genom att erbjuda ytterligare funktioner som överbelastade operatörer, destruktörer och automatisk minneshantering.
Rust använder strukturer för att utföra smarta pekare; sålunda har smarta pekare också ägandemöjligheter.
När du länkar minne som innehåller dynamiskt allokerad data med smarta pekare, avallokeras de automatiskt. Smarta pekare ger funktionalitet för att styra Rusts objekts livstid
, vilket gör dem praktiska för att förhindra fel som nollpekareavledning och minnesläckor som är populära i andra lågnivåspråk som C och C++.Fördelar med att använda smarta pekare
Här är några fördelar med att använda smarta pekare:
- Automatisk minneshantering: Smarta pekare ger automatisk minneshantering, inklusive allokering och avallokering, i motsats till manuell minneshantering med vanliga pekare.
- Förbättrad säkerhet: Smarta pekare framtvingar ägarsemantik, vilket säkerställer att endast en ägare kan komma åt resurser per gång, vilket förhindrar dataspår och samtidighetsrelaterade buggar.
- Flexibilitet: Rust ger flera smarta pekare, var och en med sin uppsättning ägande semantik för att skriva säker kod flexibelt.
- Resurshantering: Du kan använda smarta pekare för att hantera andra resurser som filhanterare och nätverksuttag genom att kapsla in resurserna inom en smart pekare som gör det lättare att hantera sin livscykel och se till att de stängs och släpps på rätt sätt efteråt använda sig av.
- Förbättrad prestanda: Smarta pekare hjälper till att förbättra prestandan genom att minska minneskopiering och allokering – minskat minnesavtryck från att använda smarta pekare resulterar i ökad prestanda.
Smarta pekare är lämpliga för medelstora till stora applikationer, särskilt i fall där minneshantering är kritisk.
Typer av smarta pekare
Rust ger flera typer av smarta pekare, inklusive Låda, Rc, RefCell, och Mutex.
1. Box Smart Pointer
De Låda Smart Pointer är Rusts enklaste och vanligaste smarta pekare. De Låda smart pointer hjälper till att allokera värden på högen och skapar en inramad pekare för tillgänglighet.
De Låda Smart Pointer är praktiskt för dynamisk minnesallokering när du behöver säkerställa att minnet automatiskt avallokeras när pekarna är utanför räckvidd.
Så här kan du deklarera och använda en Låda pekare:
fnhuvud(){// ny instans av boxens smarta pekare
låta x = Låda::ny(5);
println!(x)
}
De Låda typ är en del av Rusts förspel, så du behöver inte importera typen, till skillnad från andra smarta pekare.
De x variabel är a Låda pekare som pekar på värdet 5 heltal. Rust allokerar minnet för värdet på högen och avallokeras automatiskt när variabeln är utanför räckvidd.
2. Rc Smart Pointer
De Rc (Referens räknad) smart pekare ger funktionalitet för att skapa värden för delat ägande. De Rc smarta pekare spårar antalet referenser till ett värde och avallokerar värdet när den sista referensen är utanför omfånget.
De Rc smart pointer är praktiskt när du behöver dela ägandet av ett värde för tillgänglighet i flera delar av ditt program.
Att deklarera en Rc smart pekare importerar du Rc struct från standardbiblioteket, deklarera en ny Rc pekare med ny funktionen och klona pekarvariabeln med klona variabel.
använda sig av std:: rc:: Rc;fnhuvud() {
// ny instans av den smarta RC-pekaren
låta x = Rc:: ny(5);
låta y = Rc:: klon(&x);
println!("x = {}, y = {}"x, y);
}
De x variabeln är Rc pekarvariabel och y variabel är en klon med tillgång till värdet i minnet. Referensräkningen är två, och värdet deallokeras från minnet när variablerna är utanför räckvidden.
3. RefCell Smart Pointer
De RefCell smart pointer ger inre föränderlighet som tillåter oföränderliga och föränderliga referenser att samexistera så länge det finns en föränderlig referens per given tid.
De RefCell smart pointer är praktiskt när du muterar värden som ägs av föränderliga referenser.
De Refcell funktion är inte en del av Rusts förspel, så du måste importera strukturen från standardbiblioteket för att använda den smarta pekaren.
använda sig av std:: cell:: RefCell;fnhuvud(){
// ny instans av Refcell smarta pekare
låta x = RefCell:: new(5);låta y = x.borrow();
låta z = x.borrow_mut();println!("y = {}", *y);
println!("z = {}", *z);
}
De Refcell smart pointer innehåller värdet och y variabel är den oföränderliga referensen till värdet. De låna_mut funktion skapar en föränderlig referens för värdet.
Programmet är säkert om det bara finns en föränderlig referens åt gången.
4. Mutex Smart Pointer
De Mutex smart pointer ger ömsesidiga uteslutningar. De Mutex smart pointer är praktisk för att synkronisera åtkomst till värden över flera trådar i samtidiga program.
De Mutex smart pointer ger ömsesidig uteslutning för att säkerställa att endast en tråd kan komma åt värdet samtidigt som dataspår förhindras.
Du måste importera Mutex strukturera och skapa en ny instans med ny funktion att använda Mutex Smart Pointer i rost.
använda sig av std:: sync:: Mutex;fnhuvud() {
// ny instans av mutex-pekaren
låta räknare = Mutex:: new(0);{
låtamut num = counter.lock().unwrap();
*num += 1;
}
println!("Resultat: {}", *counter.lock().unwrap());
}
De disken variabeln är den nya Mutex exempel. De huvud funktionen får ett lås på mutexen med låsa metod för Mutex exempel. Låset möjliggör säker modifiering av räknarens värde innan du släpper låset och skriver ut värdet.
De Mutex typ garanterar att endast en tråd kan komma åt de delade resurserna (i det här fallet disken variabel) och ändra dess värde åt gången. Den ömsesidiga uteslutningen säkerställer att samtidig åtkomst till delade resurser serialiseras för att förhindra dataspår och andra samtidiga problem.
Rusts ägarmodell garanterar minnessäkerhet
Smarta pekare är en av Rusts metoder för minnessäkerhet och flexibilitet. Rusts ägarmodell säkerställer att program använder minnet på ett säkert sätt med lånekontrollen vid kompilering.
Lånekontrollen är ett avgörande inslag i Rusts ägarmodell som upprätthåller strikta regler för minnestillgänglighet och modifiering.