Rust: What is the difference between Box and Rc?

Box gives you exclusive ownership of heap data — one owner, immediate cleanup. Rc gives shared ownership — multiple owners, cleanup happens when the last owner drops.

Box — exclusive ownership:

• Exactly one variable owns the data.
• Ownership moves on assignment (no Copy).
• Data is freed deterministically when the Box goes out of scope.
• Ideal for single-owner heap allocation.

1fn process(data: Box<Vec<i32>>) {
2    println!("Processing {} items", data.len());
3    // data is freed when function returns
4}
5
6let my_data = Box::new(vec![1, 2, 3, 4, 5]);
7process(my_data);  // Ownership moved into function
8// my_data is no longer valid here

Rc — shared ownership:

• Multiple variables own the same data.
• Reference count tracks active owners.
• Data freed when count reaches zero.
• Perfect for shared, read-only data.

1use std::rc::Rc;
2
3struct SharedState {
4    users: Vec<String>,
5    max_connections: usize,
6}
7
8let state = Rc::new(SharedState {
9    users: vec!["alice".into(), "bob".into()],
10    max_connections: 100,
11});
12
13let handler1 = Rc::clone(&state);
14let handler2 = Rc::clone(&state);
15let handler3 = Rc::clone(&state);
16
17// All handlers access the same SharedState
18println!("Users: {}", handler1.users.len());
19println!("Max: {}", handler2.max_connections);
20println!("Refs: {}", Rc::strong_count(&state));  // 4

When to use Box:

• Recursive types (enum List { Cons(i32, Box<List>), Nil }).
• Large data to avoid stack overflow.
• Trait objects for dynamic dispatch.

When to use Rc:

• Shared configuration or state across components.
• Graphs or trees with shared nodes.
• Read-only shared data.

Common mistakes:

• Using Rc when Box suffices.
• Trying to mutate Rc data without RefCell.
• Creating reference cycles (use Weak to break them).