Smart Pointers in Rust

# CHAPTER 19

Smart Pointers in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Understand what a Smart Pointer is (Deref and Drop traits).

• Use Box<T> to force data onto the Heap.

• Use Rc<T> to allow multiple owners of the same data.

• Use RefCell<T> for "Interior Mutability."

3. What is a Smart Pointer? #

They are usually implemented using structs that possess the Deref trait (allowing them to behave like standard references) and the Drop trait (allowing them to execute cleanup code when they go out of scope).

4. Box<T> (Allocating on the Heap) #

When to use it:

1. 1. When you have a massive amount of data and want to avoid copying it on the Stack.

1. 2. When you have a Recursive Type (a type that contains itself).

Because the compiler needs to know exactly how many bytes a struct takes up, a recursive struct (like a Linked List node) has an infinite size! Box<T> fixes this because a Box is just a pointer, and pointers have a known, fixed size.

// Recursive enum representing a Linked List
enum List {
    Cons(i32, Box<List>), // Box ensures the compiler knows the size!
    Nil,
}

use List::{Cons, Nil};

fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Nil))));
    
    // Simple Box usage for an integer
    let b = Box::new(5);
    println!("b = {}", b);
}

5. Rc<T> (Reference Counted Smart Pointer) #

Rc<T> (Reference Counted) allows multiple owners. It keeps a secret counter of how many variables own the data. When an owner goes out of scope, the counter decreases. The heap memory is only deleted when the counter hits zero.

use std::rc::Rc;

fn main() {
    let shared_data = Rc::new(String::from("Shared String"));
    
    // Rc::clone doesn't copy the string data! It just increments the counter.
    let owner1 = Rc::clone(&shared_data);
    let owner2 = Rc::clone(&shared_data);
    
    println!("Reference count: {}", Rc::strong_count(&shared_data)); // Prints 3
}

*(Warning: Rc<T> is strictly for single-threaded scenarios. For multi-threading, you must use Arc<T> which we will cover in Chapter 22).*

6. RefCell<T> (Interior Mutability) #

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);

    // We borrow it mutably at runtime
    *data.borrow_mut() += 10;
    
    println!("Data is now: {}", data.borrow()); // Prints 15
}

*(Warning: If you break the borrowing rules with RefCell at runtime (e.g., calling borrow_mut() twice in the same scope), the program will Panic and crash!)*

7. Common Mistakes #

• Using Rc<T> across Threads: Passing an Rc into a thread will cause a compiler error because the internal counter is not thread-safe.

• Reference Cycles (Memory Leaks): If you use Rc and RefCell to create a cycle (Node A points to Node B, and Node B points back to Node A), their reference counters will never reach zero. This creates a memory leak in Rust!

8. Best Practices #

• Default to standard references: Do not use Smart Pointers unless standard ownership and borrowing absolutely cannot solve your architectural problem. They introduce slight overhead and complexity.

9. Exercises #

1. 1. Create a variable storing a massive float 3.14159 directly on the heap using Box::new().

1. 2. Print the value.

10. MCQs with Answers #

11. Interview Questions #

• Q: Describe a scenario where you would use Box<T>.

• Q: Explain "Interior Mutability" and how RefCell achieves it.

• Q: How does Rc<T> manage memory without a global Garbage Collector?

12. Summary #

13. Next Chapter Recommendation #