Rust: What is the difference between Box and Rc?

Box is a heap-allocating smart pointer with strict single ownership — when it goes out of scope, the data is immediately freed. Rc (Reference Counted) allows multiple owners of the same heap data through reference counting — data is freed only when the last owner drops.

Box — single owner, immediate cleanup:

• One variable owns the data at a time.
• Ownership can be moved but not duplicated.
• Data lifetime is deterministic — freed the moment the Box is dropped.
• Zero-cost: just a raw pointer, no runtime bookkeeping.

1fn create_list() -> Box<dyn std::fmt::Display> {
2    Box::new("hello")  // Returns trait object — size unknown at call site
3}
4
5let data = Box::new([0u8; 1024 * 1024]);  // 1MB on heap
6// Freed immediately when `data` goes out of scope

Rc — shared ownership, deferred cleanup:

• Multiple variables can own the same data.
• Reference count decrements when owners are dropped.
• Data lives as long as at least one Rc exists.
• Small runtime cost for counting (but negligible in most cases).

1use std::rc::Rc;
2
3#[derive(Debug)]
4struct Config {
5    name: String,
6    timeout: u32,
7}
8
9let config = Rc::new(Config { name: "prod".into(), timeout: 30 });
10
11// Multiple parts of the app share the same config
12let db_pool = Rc::clone(&config);
13let cache = Rc::clone(&config);
14let logger = Rc::clone(&config);
15
16println!("Config shared by {} components", Rc::strong_count(&config));  // 4

When to use Box:

• Recursive data structures (linked lists, trees).
• Large data you want to avoid copying.
• Trait objects (Box<dyn Error>).
• When you only need one owner.

When to use Rc:

• Shared configuration across components.
• Graph structures with shared nodes.
• Cache layers where multiple readers exist.

Common mistakes:

• Using Rc when Box is sufficient — unnecessary overhead.
• Trying to mutate Rc data without RefCell.
• Creating reference cycles (Rc → Rc → Rc → back to start).
• Using Rc in multi-threaded code (use Arc).