19.1 The Concept of Smart Pointers

A pointer represents an address in memory where data is stored. In C, pointers are ubiquitous but also perilous, as you must manually manage memory and ensure correctness. Rust usually encourages references—&T for shared access and &mut T for exclusive mutable access—which do not own data and never require manual deallocation. These references are statically checked by the compiler to avoid dangling or invalid pointers.

A smart pointer differs fundamentally because it owns the data it points to. This ownership implies:

  • The smart pointer is responsible for freeing the memory when it goes out of scope.
  • You don’t need manual free() calls.
  • Rust’s compile-time checks ensure correctness, preventing double frees and other memory misuses.

Smart pointers typically enhance raw pointers with additional functionality: reference counting, interior mutability, thread-safe sharing, and more. While safe code generally avoids raw pointers, these higher-level abstractions unify Rust’s memory safety guarantees with the flexibility of pointers.

19.1.1 When Do You Need Smart Pointers?

Many Rust programs only require stack-allocated data, references for borrowing, and built-in collections like Vec<T> or String. However, smart pointers become necessary when you:

  1. Need explicit heap allocation beyond what built-in collections provide.
  2. Require multiple owners of the same data (e.g., using Rc<T> in single-threaded code or Arc<T> across threads).
  3. Need interior mutability—the ability to mutate data even through what appears to be an immutable reference.
  4. Plan to implement recursive or self-referential data structures, such as linked lists, trees, or certain graphs.
  5. Must share ownership across threads safely (using Arc<T> with possible locks like Mutex<T>).

If these scenarios don’t apply to your program, you might never need to explicitly use smart pointers. Rust’s emphasis on stack usage and built-in types is typically sufficient for many applications.