Stack, heap, and Box, Rc, Arc

The common ones

1use std::cell::RefCell;2use std::rc::Rc;3use std::sync::Arc;4use std::thread;5 6#[derive(Debug)]7enum List {8    Cons(i32, Box<List>), // Box gives the recursive type a known size9    Nil,10}11 12fn sum(list: &List) -> i32 {13    match list {14        List::Cons(v, rest) => v + sum(rest),15        List::Nil => 0,16    }17}18 19fn main() {20    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));21    println!("{list:?} sum={}", sum(&list));22 23    let shared = Rc::new(RefCell::new(vec![1]));24    let other = Rc::clone(&shared); // a second owner, not a copy of the Vec25    other.borrow_mut().push(2);     // borrow rules checked at run time26    println!("{:?} owners={}", shared.borrow(), Rc::strong_count(&shared));27 28    let config = Arc::new(String::from("prod"));29    let handles: Vec<_> = (0..2)30        .map(|i| {31            let config = Arc::clone(&config); // atomic count: safe across threads32            thread::spawn(move || format!("worker {i} on {config}"))33        })34        .collect();35    for h in handles {36        println!("{}", h.join().unwrap());37    }38}

It prints Cons(1, Cons(2, Nil)) sum=3, [1, 2] owners=2, then worker 0 on prod and worker 1 on prod.

• Box<T>: one owner, value on the heap. Use it for recursive types, for large values you want to move cheaply, and for trait objects (Box<dyn Trait>).
• Rc<T>: several owners on one thread. Rc::clone increments a counter; the value is dropped when the last Rc goes. An Rc only gives shared (&T) access.
• Arc<T>: the same, with an atomic counter, so it can cross threads. The atomic operations cost a little more, which is why Rc exists.
• RefCell<T>: interior mutability. borrow() and borrow_mut() apply the shared-or-mutable rule at run time and panic on a violation. Rc<RefCell<T>> is the usual single-threaded "shared and mutable" combination; across threads it is Arc<Mutex<T>> or Arc<RwLock<T>>.
• Cell<T> swaps whole Copy values in and out with no borrow tracking at all.

Costs and traps

Every one of these makes a cost visible in the type: a heap allocation, a counter update, a run-time borrow check. That is the trade Rust makes: you pay only where you ask for flexibility.

Reference counting can't free cycles. Two Rcs pointing at each other keep each other's count above zero forever. For parent links, trees and observer lists, make the back-pointer a Weak<T> (from Rc::downgrade), which doesn't keep the value alive; upgrade() returns None once it is gone.

A RefCell panic (on Rust 1.99 the message is RefCell already borrowed) is the run-time version of a borrow-checker error. If you hit them often, restructure so that ownership is clear rather than wrapping more in RefCell.

Heap or stack is mostly invisible in safe code: moving a Box moves only the pointer, and dereferencing works through Deref, so *b, b.method() and &*b all reach the value inside.