What is the difference between Box and Rc?

Question

Accepted Answer

**Box** = exclusive ownership, heap allocation, no runtime overhead. **Rc** = shared ownership, heap allocation, reference counting overhead. Box for one owner; Rc for many.

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

```rust
let big_data = Box::new([0u8; 1024]);
let moved = big_data;  // Move, not copy
println!("Size: {}", moved.len());  // 1024
// big_data is invalid here
```

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

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

struct SharedResource {
    name: String,
    data: Vec<u8>,
}

let resource = Rc::new(SharedResource {
    name: "shared".into(),
    data: vec![1, 2, 3],
});

let worker1 = Rc::clone(&resource);
let worker2 = Rc::clone(&resource);

println!("{}: {:?}", worker1.name, worker1.data);
println!("Refs: {}", Rc::strong_count(&resource));  // 3
```

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

**When to use Rc:**
- Shared state across components.
- Multiple readers of 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?