Rust Study Session #15

Summary

• What is a pointer.
• Using Box<T> to point to data on the heap.
• Smart Pointers as regular references.
• Running code on cleanup.
• Rc<T>, the Reference Counted smart pointer.

Pointers

What is a pointer

• In general, a pointer is a variable that contains an address in memory.
• Such address refers to some other data.

Reference

• Most common type of pointer is the reference.
• Indicated by &, only borrows the value it points to.
• References are simple pointers.
• There is no overhead.

Smart Pointers

• Data structures with additional metadata capabilities.
• Can own the data they point to.
• Originated in C++, also available in other languages.

Smart Pointers

• String
• Vec<T>
• Reference Counting smart pointer type:
  • Keeps track of data owners.
  • Clean up when no more owners remain.

Smart Pointers

• Usually implemented as Structs.
• Implement the Deref and Drop traits:
  • Deref: to behave as a Reference.
  • Drop: behaviour when getting out of scope.

Smart Pointers

• Box<T> for allocating values on the heap.
• Rc<T> to enable multiple ownership.
• (Ref<T> and RefMut<T>, accessed through RefCell<T>)
• (Interior mutability and reference cycles)

Using Box<T> to point to data

• Only the pointer is stored on the stack.
• The data is stored on the heap.
• No performance overhead.

Box<T> to point data

Use when:

• A type size is not know at compile time.
• Transfer ownership of a large amount of data without copying the data itself.
• To own a value for which its type implements a particular trait.

Box<T> to store data

fn main() {
    // Box points to 5 allocated on the heap
    let b = Box::new(5);
    println!("b = {}", b);
}

Box<T>

Enabling recursive types

• The size of a recursive type can not be known at compile time.
• Boxes have a known size, therefore they can be used in recursive types.

Cons List

Example

enum List {
    Cons(i32, List),
    Nil,
}

Equivalent to

use crate::List::{Cons, Nil};
 
fn main() {
    let list = Cons(1, Cons(2, Cons(3, Nil)));
}

Cons List

Cons List

Compilation of recursive types

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0072]: recursive type `List` has infinite size
 --> src/main.rs:1:1
  |
1 | enum List {
  | ^^^^^^^^^ recursive type has infinite size
2 |     Cons(i32, List),
  |               ---- recursive without indirection
  |
  = help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `List` representable
 
error[E0391]: cycle detected when processing `List`
 --> src/main.rs:1:1
  |
1 | enum List {
  | ^^^^^^^^^
  |
  = note : ...which again requires processing `List`, completing the cycle
  = note : cycle used when computing dropck types for `Canonical { max_universe: U0, variables: [], value: ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, def_id: None }, value: List } }`
 
error: aborting due to 2 previous errors
 
Some errors have detailed explanations: E0072, E0391.
For more information about an error, try `rustc --explain E0072`.
error: could not compile `cons-list`.
 
To learn more, run the command again with --verbose.

Cons List (using Box<T>)

enum List {
    Cons(i32, Box<List>),
    Nil,
}
 
use crate::List::{Cons, Nil};
 
fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}

Cons List (using Box<T>)

Smart Pointers as a Reference

The Deref trait

Customise the behaviour of the deference operator *

Regular references

fn main() {
    let x = 5;
    let y = &x;
 
    assert_eq!(5, x);
    assert_eq!(5, *y);  // using the deference operator
}

Box<T> as a reference

fn main() {
    let x = 5;
    let y = Box::new(x);
 
    assert_eq!(5, x);
    assert_eq!(5, *y);  // using the deference operator
}

Using a custom smart pointer

struct MyBox<T>(T);
 
impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);
 
    assert_eq!(5, x);
    assert_eq!(5, *y);
}

Using a custom smart pointer

$ cargo run
   Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
  --> src/main.rs:14:19
   |
14 |     assert_eq!(5, *y);
   |                   ^^
 
error: aborting due to previous error
 
For more information about this error, try `rustc --explain E0614`.
error: could not compile `deref-example`.
 
To learn more, run the command again with --verbose.

Using a custom smart pointer

Implementing the Deref trait

use std::ops::Deref;
 
impl<T> Deref for MyBox<T> {
    type Target = T;
 
    fn deref(&self) -> &T {
        &self.0
    }
}

Deref coercion

Converts a type that implement the deref trait into a reference to another type.

Example

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m);
}

Defer coercion and mutability

Use the DerefMut trait to override the * operator on mutable references.

• From &T to &U when T: Deref<Target=U>
• From &mut T to &mut U when T: DerefMut<Target=U>
• From &mut T to &U when T: Deref<Target=U>

Running code on cleanup

The Drop trait

struct CustomSmartPointer {
    data: String,
}
 
impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

The Drop trait

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
    Finished dev [unoptimized + debuginfo] target(s) in 0.60s
     Running `target/debug/drop-example`
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!

Dropping a value early

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created.");
    c.drop();
    println!("CustomSmartPointer dropped before the end of main.");
}

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
error[E0040]: explicit use of destructor method
  --> src/main.rs:16:7
   |
16 |     c.drop();
   |       ^^^^ explicit destructor calls not allowed
 
error: aborting due to previous error

Dropping a value early (fix)

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created.");
    drop(c);  // std::mem::drop
    println!("CustomSmartPointer dropped before the end of main.");
}

$ cargo run
   Compiling drop-example v0.1.0 (file:///projects/drop-example)
    Finished dev [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/drop-example`
CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.

Rc<T>, the Reference Counted smart pointer

A single value might have multiple owners.

Implement a graph

use crate::List::{Cons, Nil};
 
fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
    let b = Cons(3, Box::new(a));
    let c = Cons(4, Box::new(a));
}

Implement a graph

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
  --> src/main.rs:11:30
   |
9  |     let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
   |         - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 |     let b = Cons(3, Box::new(a));
   |                              - value moved here
11 |     let c = Cons(4, Box::new(a));
   |                              ^ value used here after move
 
error: aborting due to previous error
 
For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list`.
 
To learn more, run the command again with --verbose.

Implement a graph (fix)

enum List {
    Cons(i32, Rc<List>),
    Nil,
}
 
use crate::List::{Cons, Nil};
use std::rc::Rc;
 
fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    let b = Cons(3, Rc::clone(&a));
    let c = Cons(4, Rc::clone(&a));
}

Implement a graph (rc check)

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}

Implement a graph (rc check)

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished dev [unoptimized + debuginfo] target(s) in 0.45s
     Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

References

From The Rust Programming Language book:

• Ch. 15: Smart Pointers [EN] [JP]