What is the difference between Box and Rc?

Question

Accepted Answer

**Box** = one owner, heap data, immediate cleanup, no overhead. **Rc** = many owners, heap data, reference-counted cleanup, small overhead. Box for exclusive; Rc for shared.

**Box — exclusive ownership:**
- One variable owns the data.
- Ownership moves on assignment.
- Data freed when Box drops.
- Zero runtime cost.

```rust
fn create_node(value: i32) -> Box<dyn std::fmt::Display> {
    Box::new(value)
}

let node = create_node(42);
println!("{}", node);  // 42
// node is freed when it goes out of scope
```

**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 SharedConfig {
    debug_mode: bool,
    max_retries: u32,
}

let config = Rc::new(SharedConfig { debug_mode: true, max_retries: 3 });
let db = Rc::clone(&config);
let api = Rc::clone(&config);

println!("Debug: {}", db.debug_mode);  // true
println!("Retries: {}", api.max_retries);  // 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?