Rust: What is the difference between Box and Rc in Rust?

Box is a smart pointer that provides single ownership of heap-allocated data. Rc (Reference Counted) is a smart pointer that allows multiple owners of the same heap-allocated data through reference counting.

Box — single ownership:

• Allocates data on the heap and owns it exclusively.
• When the Box goes out of scope, the data is automatically dropped.
• Enables recursive types (like linked lists) since the size is known at compile time via indirection.
• Cannot be shared — only one variable can own the Box at a time.

1let b = Box::new(5);
2let b2 = b;  // Ownership moves to b2
3// println!("{}", b);  // Error! b is no longer valid
4println!("{}", b2);  // 5

Rc — multiple ownership:

• Uses reference counting to track how many owners exist.
• Data is dropped only when the last Rc is dropped (count reaches 0).
• Only works in single-threaded contexts (not Send/Sync).
• Cannot mutate the inner data (use RefCell for interior mutability).

1use std::rc::Rc;
2
3let rc1 = Rc::new(vec![1, 2, 3]);
4let rc2 = Rc::clone(&rc1);  // Increments count
5let rc3 = Rc::clone(&rc1);  // Increments count again
6println!("Count: {}", Rc::strong_count(&rc1));  // 3
7drop(rc3);  // Decrements count to 2
8println!("Count: {}", Rc::strong_count(&rc1));  // 2
9// Data stays alive as long as rc1 or rc2 exist

When to use Box:

• When you need a single owner of heap data.
• For recursive data structures (enum Node { Next(Box<Node>) }).
• When you need to move large data without copying.
• For trait objects when size is unknown at compile time.

When to use Rc:

• When multiple parts of your code need to read the same data.
• For shared data structures like graphs or trees with multiple parent references.
• When you want shared ownership without copying data.

Common mistakes:

• Trying to use Rc in multi-threaded code (use Arc instead).
• Creating reference cycles (use Weak to break them).
• Trying to mutate through Rc without RefCell.
• Using Rc when Box would suffice — unnecessary overhead.