What is the difference between Box and Rc?

Question

Accepted Answer

**Box** = one owner, heap data, immediate cleanup. **Rc** = many owners, heap data, reference-counted cleanup. Box is simpler and faster; Rc is more flexible for shared ownership.

**Box — single owner:**
- One variable owns the data.
- Ownership transfers on move.
- Data freed when Box drops.
- No runtime cost.

```rust
let boxed = Box::new(String::from("hello"));
let moved = boxed;  // Ownership transferred
println!("{}", moved);  // "hello"
// boxed is now invalid
```

**Rc — multiple owners:**
- Multiple variables own the same data.
- Reference count tracks owners.
- Data freed when count reaches zero.
- Small runtime cost.

```rust
use std::rc::Rc;

let shared = Rc::new(vec![1, 2, 3]);
let a = Rc::clone(&shared);
let b = Rc::clone(&shared);

// All three point to the same Vec
println!("{} {} {}", shared[0], a[1], b[2]);  // 1 2 3
println!("Count: {}", Rc::strong_count(&shared));  // 3
```

**When to use Box:**
- Recursive types, trait objects, large data.
- Single-owner scenarios.
- Performance-critical code.

**When to use Rc:**
- Shared state, graphs, caches.
- Multiple readers of the same data.
- Single-threaded contexts.

**Common mistakes:**
- Using Rc when Box works.
- Mutating Rc without RefCell.
- Creating reference cycles.

Rust: What is the difference between Box and Rc?