pointers/ref

For pointers, a distinction needs to be made between destructuring
and dereferencing as they are different concepts which are used
differently from a language like C.

  • Dereferencing uses *
  • Destructuring uses &, ref, and ref mut
  1. fn main() {
  2.     // Assign a reference of type `i32`. The `&` signifies there
  3.     // is a reference being assigned.
  4.     let reference = &4;
  6.     match reference {
  7.         // If `reference`s is pattern matched against `&val`, it results
  8.         // in a comparison like:
  9.         // `&i32`
  10.         // `&val`
  11.         // ^ We see that if the matching `&`s are dropped, then the `i32`
  12.         // should be assigned to `val`.
  13.         &val => println!("Got a value via destructuring: {:?}", val),
  14.     }
  16.     // To avoid the `&`, you dereference before matching.
  17.     match *reference {
  18.         val => println!("Got a value via dereferencing: {:?}", val),
  19.     }
  21.     // What if you don't start with a reference? `reference` was a `&`
  22.     // because the right side was already a reference. This is not
  23.     // a reference because the right side is not one.
  24.     let _not_a_reference = 3;
  26.     // Rust provides `ref` for exactly this purpose. It modifies the
  27.     // assignment so that a reference is created for the element; this
  28.     // reference is assigned.
  29.     let ref _is_a_reference = 3;
  31.     // Accordingly, by defining 2 values without references, references
  32.     // can be retrieved via `ref` and `ref mut`.
  33.     let value = 5;
  34.     let mut mut_value = 6;
  36.     // Use `ref` keyword to create a reference.
  37.     match value {
  38.         ref r => println!("Got a reference to a value: {:?}", r),
  39.     }
  41.     // Use `ref mut` similarly.
  42.     match mut_value {
  43.         ref mut m => {
  44.             // Got a reference. Gotta dereference it before we can
  45.             // add anything to it.
  46.             *m += 10;
  47.             println!("We added 10. `mut_value`: {:?}", m);
  48.         },
  49.     }
  50. }