Rust — Smart Pointers

Box<T>

fn main() {
    let b = Box::new(5);
    println!("Value: {}", b);

    // Recursive type
    enum List {
        Cons(i32, Box<List>),
        Nil,
    }

    use List::{Cons, Nil};
    let list = Cons(1, Box::new(Cons(2, Box::new(Nil))));
}

Rc<T>

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("Hello"));
    let b = Rc::clone(&a);
    let c = Rc::clone(&a);

    println!("Count: {}", Rc::strong_count(&a)); // 3
    println!("{} {} {}", a, b, c);
}

RefCell<T>

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(vec![1, 2, 3]);

    // Borrow mutably at runtime
    data.borrow_mut().push(4);

    // Borrow immutably
    println!("{:?}", data.borrow());
}

Rc<RefCell<T>>

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

fn main() {
    let shared = Rc::new(RefCell::new(vec![1, 2, 3]));

    let mut data = shared.borrow_mut();
    data.push(4);
    drop(data);

    println!("{:?}", shared.borrow());
}

Weak<T>

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

fn main() {
    let strong = Rc::new(String::from("Hello"));
    let weak: Weak<String> = Rc::downgrade(&strong);

    // Upgrade to strong reference
    if let Some(value) = weak.upgrade() {
        println!("Value: {}", value);
    }
}

Mini Practice

Write Rust code that:

1. Uses Box for heap allocation
2. Uses Rc for shared ownership
3. Uses RefCell for interior mutability
4. Combines Rc<RefCell<T>>

Up Next

In the next lesson, you'll learn about Concurrency — threads and async.