Rust Smart Pointers Explained

Smart pointers in Rust provide additional functionality beyond regular references (&T), such as heap allocation, reference counting, interior mutability, and thread safety.

Box: Heap Allocation and Ownership

What is Box?

• A smart pointer that allocates data on the heap.
• Useful for large data structures or recursive types.
• Has single ownership → Moves on assignment.

How to Use Box

fn main() {
    let x = Box::new(5); // `x` stores the heap-allocated value 5
    println!("x = {}", x);
}

Use Box when:

• You need to store data on the heap.
• You want to transfer ownership but still have Rust’s safety.
• You need indirect recursion (because Rust needs to know the size at compile time).

Don’t use Box when:

• A simple &T reference is enough.
• Performance overhead of heap allocation is unnecessary.

Rc: Multiple Owners (Reference Counting)

What is Rc?

• A reference-counted smart pointer that allows multiple owners of the same data.
• Tracks how many references exist and deallocates memory when the last reference is dropped.
• Not thread-safe (use Arc for multi-threading).

How to Use Rc

use std::rc::Rc;

fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a); // Increases reference count
    let c = Rc::clone(&a);

    println!("Reference count: {}", Rc::strong_count(&a)); // Prints: 3
}

Use Rc when:

• You need multiple owners for the same value (e.g., graph/tree structures).
• You are not working with multiple threads.

Don’t use Rc when:

• You need thread safety (Rc is not thread-safe → use Arc).
• You need mutable access (use RefCell instead).

Arc: Thread-Safe Reference Counting

What is Arc?

• A thread-safe version of Rc that allows shared ownership across threads.
• Uses atomic reference counting instead of normal reference counting.
• More expensive than Rc due to thread synchronization overhead.

How to Use Arc

use std::sync::Arc;
use std::thread;

fn main() {
    let a = Arc::new(10);
    let b = Arc::clone(&a);

    let handle = thread::spawn(move || {
        println!("Thread value: {}", b);
    });

    handle.join().unwrap();
}

Use Arc when:

• You need multiple owners across threads.
• You are working in a multi-threaded environment.

Don’t use Arc when:

• You don’t need thread safety (Rc is more efficient in single-threaded code).
• You need mutable access (use Mutex with Arc for that).

RefCell: Interior Mutability (Runtime Borrow Checking)

What is RefCell?

• Allows mutable access to data even when it’s immutable.
• Unlike Rust’s usual borrowing rules (checked at compile time), RefCell enforces borrowing rules at runtime.
• Useful when you need shared mutability in a single-threaded program.

How to Use RefCell

use std::cell::RefCell;

fn main() {
    let a = RefCell::new(5);
    *a.borrow_mut() += 10;
    println!("Updated value: {}", a.borrow());
}

Use RefCell when:

• You need mutable access but Rust’s borrowing rules make it difficult.
• You are working in a single-threaded environment.

Don’t use RefCell when:

• You need compile-time borrowing safety (since RefCell allows runtime errors for borrowing violations).
• You need thread safety (RefCell is not thread-safe → use Mutex instead).

Mutex: Thread-Safe Interior Mutability

What is Mutex<T>?

• A thread-safe way to enable interior mutability.
• Ensures that only one thread can access the data at a time (prevents data races).
• Requires locking/unlocking to access data.

How to Use Mutex

use std::sync::{Mutex, Arc};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final count: {}", *counter.lock().unwrap());
}

Use Mutex when:

• You need mutable access across multiple threads.
• You need safe concurrency management.

Don’t use Mutex when:

• You don’t need thread safety (use RefCell in single-threaded cases).
• You don’t want the overhead of locks (locks can cause performance bottlenecks).

Summary Table: Choosing the Right Smart Pointer

Smart Pointer	Ownership	Thread-Safe?	Mutable Access?	Use Case
Box	Single	Yes	No	Heap allocation, recursive types
Rc	Multiple (reference counting)	No	No	Multiple owners in single-threaded programs
Arc	Multiple (atomic reference counting)	Yes	No	Multiple owners in multi-threaded programs
RefCell	Single	No	Yes (interior mutability)	Mutable access in single-threaded programs
Mutex	Single	Yes	Yes	Mutable access in multi-threaded programs