Smarta pekare: Box, Rc och Arc
Förstå hur `Box` för heapallokering, `Rc` för delat ägarskap och `Arc` för trådsäkert delat ägarskap hanterar data.
Smarta pekare: Box, Rc och Arc är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 3. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 3 lektioner.
Vad är smarta pekare?
Rusts ägarskapssystem är utmärkt för minnessäkerhet, men ibland behöver du större flexibilitet. Det är där smarta pekare kommer in!
Smarta pekare är datastrukturer som fungerar som pekare men också innehåller ytterligare metadata och funktioner. De hanterar minne, ägarskap och andra resurser automatiskt.
Box: lagra data på heapen
Den enklaste smarta pekaren är Box<T>. Den låter dig lagra data på heapen i stället för på stacken.
- Stack: Snabba data med fast storlek.
- Heap: Långsammare data med flexibel storlek, allokerade vid körning.
När du placerar ett värde i en Box ligger själva Box på stacken, men datan som den pekar på finns på heapen.
Använda Box för heapallokering
Vi ska se hur Box flyttar data till heapen. Det är användbart för stora datamängder eller när du inte känner till storleken vid kompilering.
Kör den här koden för att se hur ett värde placeras 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
}När är Box användbart?
Du kan använda Box<T> i följande situationer:
- När du har en typ vars storlek inte kan fastställas vid kompilering och behöver lagra den någonstans med en känd, fast storlek.
- När du har en stor mängd data och vill överföra ägarskapet utan att kopiera själva datan.
- När du vill äga ett trait-objekt, till exempel
Box<dyn Trait>.
Rc: flera ägare (en tråd)
Rusts ägarskapsregler innebär att ett värde vanligtvis bara har en ägare. Men vad händer om flera delar av programmet behöver ”äga” samma data?
Rc<T>, eller Reference Counted, tillåter flera ägare av data i en entrådad miljö. Den håller reda på hur många referenser som pekar på datan.
När antalet referenser sjunker till noll rensas datan bort.
Dela data med Rc
Rc::clone() ökar antalet referenser. Detta är ingen djup kopia; det skapar bara ytterligare en pekare till samma data.
Observera hur datan delas och hur dess värde är åtkomligt från olika ”ägare”.
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: delat ägarskap (flera trådar)
Rc<T> fungerar bra i entrådade program. Om du däremot behöver dela data mellan flera trådar är Rc<T> inte säkert.
Arc<T>, eller Atomic Reference Counted, är den trådsäkra versionen av Rc<T>. Den använder atomiska operationer för att uppdatera antalet referenser, vilket garanterar säkerhet mellan trådar.
Arc har en liten prestandakostnad jämfört med Rc på grund av de atomiska operationerna.
Dela data mellan trådar med Arc
Det här exemplet visar hur Arc låter flera trådar komma åt och läsa samma delade data på ett säkert sätt. Varje tråd får sin egen `Arc`-klon.
Huvudtråden väntar tills alla skapade trådar har slutförts.
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?
Vilken smart pekare du bör välja beror på dina behov:
Box<T>: När du behöver placera data på heapen, vanligtvis för en enda ägare eller när du arbetar med rekursiva typer.Rc<T>: När du behöver flera ägare till data i en entrådad kontext.Arc<T>: När du behöver flera ägare till data i en flertrådad (samtidig) kontext.
Välj alltid Box eller Rc om du inte behöver trådsäkerhet, eftersom Arc medför en prestandakostnad.
Testa dina kunskaper om smarta pekare
Du behöver lagra en stor bildfil på heapen, och endast en del av programmet ska äga och hantera den. Vilken smart pekare bör du använda?
Sammanfattning: smarta pekare
I den här lektionen har du lärt dig om tre grundläggande smarta pekare i Rust:
Box<T>: För att allokera data på heapen med en enda ägare.Rc<T>: För att möjliggöra flera ägare till data i en entrådad miljö.Arc<T>: För att möjliggöra flera trådsäkra ägare till data i en flertrådad miljö.
Dessa smarta pekare ger dig större kontroll över minneshanteringen samtidigt som du drar nytta av Rusts säkerhetsgarantier.
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Smarta pekare: Box, Rc och Arc” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Smarta pekare: Box, Rc och Arc”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 3 lektioner.
Vad lär jag mig i ”Smarta pekare: Box, Rc och Arc”?
Förstå hur `Box` för heapallokering, `Rc` för delat ägarskap och `Arc` för trådsäkert delat ägarskap hanterar data. Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.
Hur lång tid tar lektionen ”Smarta pekare: Box, Rc och Arc”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Smarta pekare: Box, Rc och Arc
- Intern muterbarhet: RefCell och Cell
- Bekymmersfri samtidighet med trådar