⚡ Lehrpfad 3: Traits, Generics & Smart Pointer

Rust 12: Smart Pointer (Box, Rc, RefCell)

Verstehe Heapspeicher mit Box<T>, Reference Counting mit Rc<T>, Interior Mutability mit RefCell<T> und deterministisches RAII-Cleanup mit Drop.

📂 Dateien dieser Lerneinheit:
📄 aufgabe.rs (Startercode) 🧪 test_aufgabe.rs (Tests) 💡 musterloesung.rs (Lösung) 📖 README.md

⚡ 1. Die Smart-Pointer Übersicht

Smart Pointer sind Datenstrukturen, die sich wie Referenzen verhalten (über das Deref-Trait), jedoch zusätzliche Metadaten und Garantien bereitstellen.

[Box<T>]             ──> Eindeutiger Besitz (Single Owner) auf dem Heap. Für rekursive Typen.
[Rc<T>]              ──> Geteilter Besitz (Multiple Owners, Single-Threaded) via Reference Counter.
[RefCell<T>]         ──> Interior Mutability: Borrow-Checking dynamisch zur Laufzeit.
[Rc<RefCell<T>>]     ──> Mehrere Besitzer, die gemeinsam mutable Daten verändern können!
1. Box<T>

Ermöglicht Typen mit dynamischer oder rekursiver Größe wie Binärbäume.

2. Rc<T>

Zählt aktive Referenzen. Wenn strong_count == 0 wird der Speicher freigegeben.

3. RefCell<T>

borrow() (&T) und borrow_mut() (&mut T) prüfen Regeln zur Laufzeit.

🛡️ 2. Interior Mutability & RAII Drop

use std::rc::Rc;
use std::cell::RefCell;

// Shared Mutable State:
let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
let handle1 = Rc::clone(&shared_data);
let handle2 = Rc::clone(&shared_data);

handle1.borrow_mut().push(4);
handle2.borrow_mut().push(5);

println!("Daten: {:?}", shared_data.borrow()); // [1, 2, 3, 4, 5]
println!("Aktive Handles: {}", Rc::strong_count(&shared_data)); // 3

📑 3. Cheat-Sheet: Smart Pointer Vergleich

Typ Besitz (Ownership) Mutabilität Thread-Sicherheit
Box<T> Single Owner Statisch (Compile-Zeit) Ja (wenn T: Send)
Rc<T> Multiple Owners Unveränderlich (&T) Nein (Single-Thread)
RefCell<T> Single Owner Dynamisch (Laufzeit-Check) Nein (Single-Thread)
Arc<Mutex<T>> Multiple Owners Thread-sicher mutierbar Ja (Multi-Thread, ab Modul 14!)

🎯 Aufgaben & Checkliste in aufgabe.rs

💻 In Web-IDE öffnen → ← Zurück zu Rust 11 Zu Lehrpfad 4: Concurrency →