Rust Smart Pointers Practice: Box, Rc, RefCell & Arc

Before reaching for smart pointers, exhaust simpler options:

1. T, &T, &mut T — regular ownership and borrowing covers most cases
2. Vec<T>, String — owned heap buffers with simple ownership
3. Smart pointers — only when the ownership graph demands it

If you're wrapping everything in Box or Rc, step back and ask whether borrows or restructuring would work. The ownership and borrowing guide covers the borrow-first approach that eliminates most smart pointer needs.

A type that directly contains itself has no finite size. Box adds indirection with a known pointer size:

// WRONG: infinite size
// enum List {
//     Cons(i32, List),  // error[E0072]: recursive type has infinite size
//     Nil,
// }

// RIGHT: Box adds indirection
enum List {
    Cons(i32, Box<List>),
    Nil,
}

let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));

Rc uses non-atomic reference counting and does not implement Send:

// WRONG: Rc is not thread-safe
// use std::rc::Rc;
// let data = Rc::new(vec![1, 2, 3]);
// thread::spawn(move || {
//     println!("{data:?}");  // error[E0277]: Rc cannot be sent between threads
// });

// RIGHT: Arc uses atomic reference counting
use std::sync::Arc;
let data = Arc::new(vec![1, 2, 3]);
let data_clone = Arc::clone(&data);
thread::spawn(move || {
    println!("{data_clone:?}");
}).join().unwrap();

Note: Arc<T> gives you shared ownership, not shared mutation. T must still be Send + Sync to be safely shared. For mutation, pair with Mutex or RwLock. The concurrency guide covers the Arc<Mutex<T>> and channel patterns in depth.

RefCell checks borrow rules at runtime. Calling .borrow_mut() while a .borrow() is active panics:

use std::cell::RefCell;

let data = RefCell::new(vec![1, 2, 3]);

// WRONG: immutable borrow still active when we try to mutate
// let borrowed = data.borrow();
// data.borrow_mut().push(4);  // panic: already borrowed: BorrowMutError

// RIGHT: drop the immutable borrow first
{
    let borrowed = data.borrow();
    println!("{:?}", *borrowed);
}  // borrowed drops here
data.borrow_mut().push(4);  // OK

// Or use try_borrow_mut for fallible borrowing (no panic)
match data.try_borrow_mut() {
    Ok(mut guard) => guard.push(5),
    Err(_) => eprintln!("already borrowed"),
}

RefCell<T> is for interior mutability — mutating through an immutable reference, with runtime borrow checks. If you have single ownership and can use &mut T, you don't need RefCell.

// Put data on the heap
let b = Box::new(5);
println!("{}", *b);  // dereference with *

// Box for trait objects
let shapes: Vec<Box<dyn Shape>> = vec![
    Box::new(Circle { radius: 1.0 }),
    Box::new(Square { side: 2.0 }),
];

Box has zero runtime cost beyond heap allocation — no reference counting, no runtime checks.

use std::rc::Rc;

let a = Rc::new(String::from("hello"));
let b = Rc::clone(&a);  // both a and b own the data
let c = Rc::clone(&a);

println!("count: {}", Rc::strong_count(&a));  // 3
drop(c);
println!("count: {}", Rc::strong_count(&a));  // 2

Rc::clone is cheap — it increments a counter, not a deep copy. The data is dropped when the last Rc goes out of scope.

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

let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
let clone = Rc::clone(&shared);
clone.borrow_mut().push(4);
println!("{:?}", shared.borrow()); // [1, 2, 3, 4]

Rc cycles prevent deallocation — neither value's count reaches zero. Use Weak for back-pointers:

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,     // Weak: doesn't keep parent alive
    children: RefCell<Vec<Rc<Node>>>, // Rc: keeps children alive
}

let parent = Rc::new(Node {
    value: 1,
    parent: RefCell::new(Weak::new()),
    children: RefCell::new(vec![]),
});

let child = Rc::new(Node {
    value: 2,
    parent: RefCell::new(Rc::downgrade(&parent)),
    children: RefCell::new(vec![]),
});
parent.children.borrow_mut().push(Rc::clone(&child));

// Upgrade Weak to access the parent (returns Option<Rc<Node>>)
if let Some(p) = child.parent.borrow().upgrade() {
    println!("parent value: {}", p.value);
}

println!("strong: {}, weak: {}",
    Rc::strong_count(&parent),  // 1
    Rc::weak_count(&parent),    // 1
);

Pattern: children hold Rc (keep child alive), parents hold Weak (don't prevent deallocation).

Arc provides shared ownership, not shared mutation. For read-only sharing, no Mutex needed:

use std::sync::Arc;
use std::thread;

let config = Arc::new(String::from("production"));
let mut handles = vec![];
for _ in 0..3 {
    let config = Arc::clone(&config);
    handles.push(thread::spawn(move || {
        println!("mode: {config}");  // read-only — no Mutex needed
    }));
}
for h in handles { h.join().unwrap(); }

For read-heavy patterns with occasional writes, use Arc<RwLock<T>> instead of Arc<Mutex<T>> — it allows concurrent readers.

When you have a unique Arc (no other clones), Arc::get_mut() gives &mut T without a lock. Arc::make_mut() provides clone-on-write semantics. Understanding references and lifetimes helps explain why Rc and Arc exist -- they solve cases where the borrow checker cannot statically prove a single owner.

• The Rust Book: Smart Pointers — Box, Rc, RefCell, reference cycles
• The Rust Book: Reference Cycles — Weak, tree patterns
• std::rc::Rc — strong_count, weak_count, Weak API
• std::sync::Arc — get_mut, make_mut, thread-safety requirements