Rust: What is the difference between Box and Rc?

Box provides exclusive (single) ownership of heap-allocated data, while Rc (Reference Counted) provides shared ownership through reference counting. The fundamental difference is: one owner vs many owners.

Box — exclusive ownership:

• Exactly ONE owner at any time.
• Ownership can be moved (transferred) but not duplicated.
• Data is dropped immediately when the Box goes out of scope.
• Zero runtime overhead — just a pointer to heap data.

1let boxed = Box::new(String::from("owned"));
2let moved = boxed;  // Move ownership
3// boxed is now invalid — can't use it
4drop(moved);  // String is freed here

Rc — shared ownership:

• MULTIPLE owners simultaneously via Rc::clone.
• Reference count tracks active owners.
• Data is dropped when count reaches zero.
• Runtime overhead for counting (but cheap — just increment/decrement).

1use std::rc::Rc;
2
3let shared = Rc::new(vec![1, 2, 3]);
4let owner1 = Rc::clone(&shared);
5let owner2 = Rc::clone(&shared);
6// All three point to the same Vec on the heap
7println!("Owners: {}", Rc::strong_count(&shared));  // 3
8drop(owner1);
9println!("Owners: {}", Rc::strong_count(&shared));  // 2
10drop(owner2);
11drop(shared);  // Vec is freed here

When to use Box:

• When only one part of your code needs the data.
• For recursive types (linked lists, trees with Box<Node>).
• When you need deterministic, immediate cleanup.
• For trait objects (Box<dyn Trait>).

When to use Rc:

• When multiple components need the same data without copying.
• Shared caches, shared configuration, or graph structures.
• Single-threaded contexts only (use Arc for threads).

Common mistakes:

• Using Rc when Box is sufficient — adds unnecessary reference counting overhead.
• Trying to mutate through Rc — you need Rc<RefCell<T>> for interior mutability.
• Creating reference cycles with Rc — use Weak to break them.
• Using Rc in multi-threaded code — use Arc instead.