Rust: What is the difference between Box and Rc?

Box = single owner, heap allocation, no runtime overhead. Rc = multiple owners, heap allocation, reference counting overhead. Choose Box when one owner suffices; choose Rc when multiple owners are needed.

Box — simple, single ownership:

• One owner at a time (move semantics).
• Data dropped when the Box goes out of scope.
• Zero runtime overhead (just a pointer).
• Perfect for recursive types and trait objects.

1// Recursive type — only possible with Box
2enum List {
3    Cons(i32, Box<List>),
4    Nil,
5}
6
7let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));

Rc — shared ownership:

• Multiple owners (reference counted).
• Data dropped when last owner is dropped.
• Small runtime cost for counting.
• Great for shared data across components.

1use std::rc::Rc;
2
3struct Node {
4    value: i32,
5    parent: Option<Rc<Node>>,  // Multiple children can share parent
6}
7
8let parent = Rc::new(Node { value: 1, parent: None });
9let child1 = Node { value: 2, parent: Some(Rc::clone(&parent)) };
10let child2 = Node { value: 3, parent: Some(Rc::clone(&parent)) };
11// Both children share the same parent node

When to use Box:

• Recursive types, large data, trait objects.
• When one owner is sufficient.
• When you want deterministic, immediate cleanup.

When to use Rc:

• Shared configuration, graph structures, caches.
• When multiple parts need the same data.
• Single-threaded contexts only.

Common mistakes:

• Using Rc unnecessarily when Box works.
• Trying to mutate Rc without RefCell.
• Creating reference cycles with Rc.