Skip to content

pointer.md

Latest commit

 

History

History
42 lines (23 loc) · 3.39 KB

pointer.md

File metadata and controls

42 lines (23 loc) · 3.39 KB
# Rust Smart Pointers

In Rust, pointers are variables that hold an address in memory, which refers to or "points at" other data. There are two primary types of pointers in Rust: references and smart pointers.

References

A reference is the most common type of pointer in Rust. It is indicated by the & symbol and borrows the value it points to. References are lightweight pointers with no special capabilities other than referring to data. They have no overhead and are a fundamental part of Rust's ownership and borrowing system.

Smart Pointers

A smart pointer is a data structure that acts like a pointer but also includes additional metadata and capabilities. Smart pointers originated in C++ and have been implemented in various languages, including Rust.

While references only borrow data, smart pointers often own the data they point to, which is a key distinction in Rust. Smart pointers are implemented using structs and implement the Deref and Drop traits to provide extra functionality. These traits make smart pointers behave like references and allow for custom code when an instance of the smart pointer goes out of scope.

Common Smart Pointers in Rust

Rust provides several smart pointer types in the standard library:

  1. Box<T>: A smart pointer for allocating values on the heap. It allows you to store values on the heap and provides ownership semantics.
  2. Rc<T>: A reference-counted smart pointer that allows multiple ownership of the same data. It keeps track of the number of owners and cleans up the data when there are no remaining owners.
  3. Ref<T> and RefMut<T>: These smart pointers are used with RefCell<T>, a type that enforces borrowing rules at runtime instead of compile time. They enable interior mutability, allowing data to be mutated even if the RefCell<T> itself is immutable.
  4. String and Vec<T>: These types were encountered earlier in the book, and although they weren’t explicitly called smart pointers, they fit the definition. They own memory, provide metadata, and have additional capabilities, like ensuring data is valid UTF-8.

Traits: Deref and Drop

Smart pointers in Rust implement two key traits:

  • Deref: This trait allows an instance of the smart pointer to behave like a reference, meaning you can use smart pointers in places where a reference would normally be used.
  • Drop: This trait allows you to define custom logic that runs when the smart pointer goes out of scope. It is used to manage memory and other cleanup tasks.

Ownership and Borrowing

Smart pointers are an essential part of Rust’s ownership and borrowing model. While references simply borrow data, smart pointers often own the data they point to, which means they have the responsibility of cleaning up that data when it's no longer needed. This helps ensure that memory is managed safely and efficiently.

Interior Mutability Pattern

Rust also introduces the concept of interior mutability, where an immutable type can expose an API to mutate its internal data. This is primarily used with types like RefCell<T>, which allows for runtime checks of borrowing rules.

Reference Cycles and Memory Leaks

One of the challenges with smart pointers is dealing with reference cycles, where two or more smart pointers reference each other in a loop. This can result in memory leaks because the reference count never drops to zero.