Smart Pointers

Smart pointers are data structures that act like pointers but have additional metadata and capabilities. Unlike regular references, smart pointers own the data they point to. Rust's smart pointers enable advanced patterns like heap allocation, reference counting, and interior mutability.

What Are Smart Pointers?

A pointer is a variable that contains an address in memory. In Rust, the most common pointer is a reference (&). Smart pointers are data structures that not only act like pointers but also have additional metadata and capabilities.

Common Smart Pointer Types

Box<T> - Heap Allocation

Box<T> is the most straightforward smart pointer. It allows you to store data on the heap rather than the stack.

Click Run to execute your code

When to Use Box<T>

• Recursive types: Types whose size can't be known at compile time
• Large data: Transfer ownership without copying large amounts of data
• Trait objects: When you want a value with a type implementing a specific trait

Rc<T> - Reference Counting

Rc<T> enables multiple ownership by keeping track of the number of references to a value. The value is dropped when the last reference goes out of scope.

Click Run to execute your code

Rc Methods

RefCell<T> - Interior Mutability

RefCell<T> provides interior mutability - a design pattern that allows you to mutate data even when there are immutable references to that data.

Click Run to execute your code

RefCell Methods

Combining Rc<T> and RefCell<T>

A common Rust pattern is combining Rc<T> and RefCell<T> to have multiple owners with the ability to mutate data.

Click Run to execute your code

The Deref Trait

The Deref trait allows you to customize the behavior of the dereference operator *. Smart pointers implement Deref so they can be treated like regular references.

Click Run to execute your code

Deref Coercion

Deref coercion automatically converts a reference to a type implementing Deref into a reference to another type. This happens automatically when you pass a reference as an argument to a function.

The Drop Trait

The Drop trait lets you customize what happens when a value goes out of scope. Smart pointers use Drop to clean up resources.

Click Run to execute your code

Best Practices

Common Mistakes

// This creates a memory leak!
use std::rc::Rc;
use std::cell::RefCell;

struct Node {
    next: Option<Rc<RefCell<Node>>>,
}

let a = Rc::new(RefCell::new(Node { next: None }));
let b = Rc::new(RefCell::new(Node { next: Some(Rc::clone(&a)) }));
a.borrow_mut().next = Some(Rc::clone(&b));  // Cycle!

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    next: Option<Rc<RefCell<Node>>>,
    prev: Option<Weak<RefCell<Node>>>,  // Use Weak
}

let value = RefCell::new(5);
let borrow1 = value.borrow_mut();
let borrow2 = value.borrow_mut();  // Panic at runtime!

let value = RefCell::new(5);
{
    let mut borrow1 = value.borrow_mut();
    *borrow1 = 10;
}  // borrow1 dropped here
let mut borrow2 = value.borrow_mut();  // OK!

use std::rc::Rc;
use std::thread;

let data = Rc::new(5);
thread::spawn(move || {  // Error: Rc is not Send
    println!("{}", data);
});

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

let data = Arc::new(5);
let data_clone = Arc::clone(&data);
thread::spawn(move || {
    println!("{}", data_clone);
});

Exercise: Smart Pointers Practice

Click Run to execute your code

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    neighbors: RefCell<Vec<Rc<RefCell<Node>>>>,
}

impl Node {
    fn new(value: i32) -> Rc<RefCell<Node>> {
        Rc::new(RefCell::new(Node {
            value,
            neighbors: RefCell::new(vec![]),
        }))
    }

    fn add_neighbor(&mut self, neighbor: Rc<RefCell<Node>>) {
        self.neighbors.borrow_mut().push(neighbor);
    }
}

fn main() {
    let node1 = Node::new(1);
    let node2 = Node::new(2);
    let node3 = Node::new(3);

    // Connect the nodes in a cycle
    node1.borrow_mut().add_neighbor(Rc::clone(&node2));
    node2.borrow_mut().add_neighbor(Rc::clone(&node3));
    node3.borrow_mut().add_neighbor(Rc::clone(&node1));

    println!("Graph created with cycles!");
    println!("Node 1 has {} neighbors", node1.borrow().neighbors.borrow().len());
}

Summary

What's Next?

Now that you understand smart pointers, you're ready to learn about Packages, Crates, and Modules - Rust's module system for organizing code into reusable components and managing project structure.