Smart pointers: Box, Rc og Arc
Forstå, hvordan `Box` til heap-allokering, `Rc` til delt ejerskab og `Arc` til trådsikkert delt ejerskab håndterer data.
Smart pointers: Box, Rc og Arc er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 3. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.
Hvad er smarte pointere?
Rusts ejerskabssystem er fremragende til hukommelsessikkerhed, men nogle gange har du brug for større fleksibilitet. Det er her, smarte pointere kommer ind i billedet!
Smarte pointere er datastrukturer, der fungerer som pointere, men som også har yderligere metadata og funktioner. De håndterer automatisk hukommelse, ejerskab og andre ressourcer.
Box: Gem data på heapen
Den enkleste smarte pointer er Box<T>. Den lader dig gemme data på heapen i stedet for på stacken.
- Stack: Hurtige data med fast størrelse.
- Heap: Langsommere data med fleksibel størrelse, der allokeres under kørsel.
Når du placerer en værdi i en Box, ligger selve Box på stacken, mens de data, den peger på, ligger på heapen.
Brug Box til heap-allokering
Lad os se, hvordan Box flytter data til heapen. Det er nyttigt til store datamængder, eller når du ikke kender størrelsen på kompileringstidspunktet.
Kør denne kode for at se, hvordan en værdi placeres i en Box.
fn main() {
let x = 5; // x is on the stack
let boxed_x = Box::new(x); // x's value is moved to the heap, boxed_x is on stack
println!("Value on stack: {}", x);
println!("Value in Box (on heap): {}", *boxed_x); // Dereference to get value
}Hvornår er Box nyttig?
Du kan bruge Box<T> i følgende situationer:
- Når du har en type, hvis størrelse ikke kan kendes på kompileringstidspunktet, og du har brug for at gemme den et sted med en kendt, fast størrelse.
- Når du har en stor datamængde og vil overføre ejerskabet uden at kopiere selve dataene.
- Når du vil eje et trait-objekt, f.eks.
Box<dyn Trait>.
Rc: Flere ejere (én tråd)
Rusts ejerskabsregler betyder normalt, at en værdi kun har én ejer. Men hvad nu, hvis flere dele af dit program har brug for at "eje" de samme data?
Rc<T>, eller referenceoptælling, gør det muligt at have flere ejere af data i en enkelttrådet situation. Den holder styr på, hvor mange referencer der peger på dataene.
Når tælleren falder til nul, ryddes dataene op.
Del data med Rc
Rc::clone() øger referenceoptællingen. Det er ikke en dyb kopi; den opretter blot endnu en pointer til de samme data.
Bemærk, hvordan dataene deles, og hvordan deres værdi er tilgængelig fra forskellige "ejere".
use std::rc::Rc;
fn main() {
let value = Rc::new(String::from("Shared String"));
println!("Count after creation: {}", Rc::strong_count(&value));
let value_clone_a = Rc::clone(&value); // Increment count
println!("Count after clone A: {}", Rc::strong_count(&value));
{
let value_clone_b = Rc::clone(&value); // Increment count
println!("Count after clone B: {}", Rc::strong_count(&value));
println!("Data from A: {}", value_clone_a);
println!("Data from B: {}", value_clone_b);
} // value_clone_b goes out of scope, count decreases
println!("Count after B goes out of scope: {}", Rc::strong_count(&value));
}Arc: Delt ejerskab (flere tråde)
Rc<T> fungerer godt i enkelttrådede programmer. Hvis du derimod har brug for at dele data mellem flere tråde, er Rc<T> ikke sikker.
Arc<T>, eller atomisk referenceoptælling, er den trådsikre version af Rc<T>. Den bruger atomiske operationer til at opdatere referenceoptællingen, hvilket sikrer sikkerhed på tværs af tråde.
Arc har en lille ydeevneomkostning sammenlignet med Rc på grund af de atomiske operationer.
Del data på tværs af tråde med Arc
Dette eksempel viser, hvordan Arc lader flere tråde få sikker adgang til og læse de samme delte data. Hver tråd får sin egen `Arc`-klon.
Hovedtråden venter på, at alle oprettede tråde afsluttes.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let mut handles = vec![];
for i in 0..3 {
let data_clone = Arc::clone(&data); // Clone Arc for each thread
let handle = thread::spawn(move || {
println!("Thread {} has data: {:?}", i, *data_clone);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("All threads finished.");
}Box, Rc eller Arc?
Valget af den rigtige smarte pointer afhænger af dine behov:
Box<T>: Når du skal placere data på heapen, typisk ved enkelt ejerskab eller ved arbejde med rekursive typer.Rc<T>: Når du har brug for flere ejere af data i en enkelttrådet kontekst.Arc<T>: Når du har brug for flere ejere af data i en flertrådet (samtidig) kontekst.
Foretræk altid Box eller Rc, hvis du ikke har brug for trådsikkerhed, da Arc har en ydeevneomkostning.
Tjek af smarte pointere
Du skal gemme en stor billedfil på heapen, og kun én del af dit program skal eje og administrere den. Hvilken smart pointer bør du bruge?
Opsummering: Smarte pointere
I denne lektion har du lært om tre grundlæggende smarte pointere i Rust:
Box<T>: Til at allokere data på heapen med enkelt ejerskab.Rc<T>: Til at gøre det muligt at have flere ejere af data i et enkelttrådet miljø.Arc<T>: Til at gøre det muligt at have flere trådsikre ejere af data i et flertrådet miljø.
Disse smarte pointere giver dig større kontrol over hukommelseshåndtering, samtidig med at du stadig udnytter Rusts sikkerhedsgarantier.
Lær Rust med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 144
Ofte stillede spørgsmål
Er lektionen “Smart pointers: Box, Rc og Arc” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Smart pointers: Box, Rc og Arc”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Smart pointers: Box, Rc og Arc”?
Forstå, hvordan `Box` til heap-allokering, `Rc` til delt ejerskab og `Arc` til trådsikkert delt ejerskab håndterer data. Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær at programmere i Rust?
Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 3.
Hvor lang tid tager lektionen “Smart pointers: Box, Rc og Arc”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?
Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Smart pointers: Box, Rc og Arc
- Interior mutability: RefCell og Cell
- Ubange concurrency med tråde