Rust Smart Pointers (Box, Rc, Arc, RefCell)

Also Known As

TL;DR

Explanation

A smart pointer is a struct that behaves like a reference but carries extra ownership and management logic, usually implementing `Deref` so you can use it like the value it points to and `Drop` so cleanup happens automatically. Rust's standard library gives you four foundational smart pointers, and knowing when each applies is central to writing idiomatic Rust beyond the borrow checker basics.

`Box<T>` is the simplest: it heap-allocates a single value and gives you sole ownership of it. You reach for it when a value's size is not known at compile time (recursive types like a linked list or tree need indirection through a Box to have a finite size), when you want to move a large value without copying its bytes, or when you need a trait object such as `Box<dyn Error>`. A Box is a single owner, just like a plain stack value, so it follows ordinary move semantics.

`Rc<T>` (reference counted) lets multiple owners share the same heap value. Each `clone` bumps a counter instead of copying the data, and the value is dropped only when the last Rc goes away. Rc is for single-threaded graphs where ownership is genuinely shared - the classic case is a node referenced by several parents. Rc gives you shared, immutable access; it is not thread-safe because its counter is not atomic.

`Arc<T>` (atomically reference counted) is the thread-safe sibling of Rc. It uses atomic operations on the count so it can be sent across threads, at a small performance cost. Use Arc whenever shared ownership crosses a thread boundary, typically paired with a Mutex or RwLock for shared mutation.

`RefCell<T>` provides interior mutability: it lets you mutate data through a shared reference by moving the borrow rules from compile time to runtime. `borrow` and `borrow_mut` hand out guards and panic if you violate the aliasing rule (many readers or one writer) while running. It is single-threaded; the thread-safe analog is Mutex. The common combination `Rc<RefCell<T>>` gives you shared, mutable, single-threaded state - powerful but easy to misuse, since RefCell turns borrow violations into runtime panics rather than compile errors.

Common Misconception

Why It Matters

Common Mistakes

• Trying to mutate the value inside an Rc directly, forgetting that Rc gives only shared immutable access and you need an inner RefCell or Mutex.
• Using Arc in single-threaded code where Rc is cheaper because it avoids atomic reference-count operations.
• Holding two borrow_mut guards (or a borrow and a borrow_mut) on the same RefCell at runtime, causing an 'already borrowed' panic.
• Creating reference cycles with Rc<RefCell<T>> that never get dropped, leaking memory because the count never reaches zero.
• Reaching for Box<T> when a plain stack value would work, adding an unnecessary heap allocation.

Avoid When

• A plain stack value or reference already satisfies the borrow checker, where adding Box or Rc just introduces an allocation or runtime overhead.
• You need shared mutation across threads, where Rc<RefCell<T>> will not compile and you must use Arc<Mutex<T>> instead.
• Your data forms cycles that Rc cannot drop, where you need Weak references or a different ownership design to avoid leaks.
• Compile-time borrow checking already expresses the access pattern, so RefCell would only move safety checks to a runtime panic for no benefit.

When To Use

• Boxing a recursive type like a tree or linked list so it has a known finite size, or storing a trait object as Box<dyn Trait>.
• Sharing read-only ownership of a value among several owners in single-threaded code with Rc.
• Sharing ownership across thread boundaries with Arc, usually combined with Mutex or RwLock for mutation.
• Mutating data behind a shared reference where the borrow rules cannot be proven at compile time, using RefCell for runtime-checked interior mutability.

Code Examples

use std::rc::Rc;

#[derive(Debug)]
struct Counter {
    value: i32,
}

fn main() {
    let shared = Rc::new(Counter { value: 0 });
    let other = Rc::clone(&shared);

    // Error: cannot mutate through an Rc - it gives shared, immutable access.
    // shared.value += 1;

    // Reaching for Arc here is needless: this is all single-threaded,
    // so the atomic counter just adds overhead.
    // let shared = std::sync::Arc::new(Counter { value: 0 });

    println!("{:?} {:?}", shared, other);
}

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

#[derive(Debug)]
struct Counter {
    value: i32,
}

fn main() {
    // Rc shares ownership; RefCell adds runtime-checked interior mutability.
    let shared = Rc::new(RefCell::new(Counter { value: 0 }));
    let other = Rc::clone(&shared);

    // Mutate through the shared reference via borrow_mut.
    shared.borrow_mut().value += 1;
    other.borrow_mut().value += 1;

    // Read access via borrow; the guard is dropped at the end of the statement.
    println!("value is {}", shared.borrow().value); // prints 2
}

References

• https://doc.rust-lang.org/book/ch15-00-smart-pointers.html
• https://doc.rust-lang.org/std/boxed/struct.Box.html
• https://doc.rust-lang.org/std/rc/struct.Rc.html
• https://doc.rust-lang.org/std/cell/struct.RefCell.html

Tags

🧠 Logic Engine