Slimme wijzers: Box en Rc

Een slimme pointer is een datastructuur die zich gedraagt ​​als een pointer, maar beschikt over metagegevens en extra mogelijkheden (zoals het tellen van referenties of automatisch geheugenbeheer).

In Rust lenen gewone referenties (zoals &) alleen gegevens. Slimme wijzers daarentegen zijn vaak eigenaar van de gegevens waarnaar ze verwijzen. Veel voorkomende voorbeelden zijn String en Vec<T>, maar de standaardbibliotheek biedt andere gespecialiseerde bibliotheek.

Box<T> voor heaptoewijzing

De eenvoudigste slimme aanwijzer is Box<T>, waarmee gegevens op de heap worden opgeslagen in plaats van op de stapel. Alleen de pointer naar de aan de heap toegewezen gegevens blijft op de stapel staan.

Het wordt voornamelijk gebruikt in de volgende gevallen:

1. Wanneer u een type heeft waarvan de grootte niet bekend is tijdens het compileren (zoals een recursief type), en u een waarde van dat type wilt gebruiken in een context die een exacte grootte vereist.
2. Wanneer u het eigendom van een grote hoeveelheid gegevens wilt overdragen zonder deze te kopiëren.

Basisvoorbeeld:

fn main() {
    let b = Box::new(5); // allocates the value 5 on the heap
    println!("b = {}", *b); // dereferences with * to read the value
}

Recursieve typen en nadelenlijsten

Een recursief type is een type dat een waarde van zichzelf kan bevatten als onderdeel van de definitie ervan. Rust moet tijdens het compileren de exacte grootte van een type weten. Omdat de diepte van een recursief type oneindig kan zijn, genereert de compiler een fout, tenzij je een Box gebruikt (die een vaste grootte heeft, omdat het een pointer is):

enum List {
    Cons(i32, Box<List>),
    Nil,
}

Rc<T>: Referentietelling

Er zijn gevallen waarin een enkele waarde meerdere eigenaren kan hebben. De slimme aanwijzer Rc<T> (Reference Counted) houdt het aantal verwijzingen naar een waarde bij om te bepalen of de waarde nog in gebruik is. Als het aantal naar nul daalt, wordt de toewijzing van de bron veilig opgeheven.

[!NOTE] Rc<T> is alleen geschikt voor scenario's met één thread. Voor scenario's met meerdere threads (gelijktijdig) moet u Arc<T> gebruiken (Atomic Reference Counted).

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    let b = Rc::clone(&a); // increments the reference count to 2
    println!("References: {}", Rc::strong_count(&a));
}

Probeer het zelf

Oefening 1: Heaptoewijzing met Box

Oefening 2: Recursieve gegevensstructuur (lijst met nadelen)

Oefening 3: Eigendom delen met Rc