Ownership and moves

Because variables are in charge of freeing their own resources,
resources can only have one owner. This also prevents resources
from being freed more than once. Note that not all variables own
resources (e.g. references).

When doing assignments (let x = y) or passing function arguments by value
(foo(x)), the ownership of the resources is transferred. In Rust-speak,
this is known as a move.

After moving resources, the previous owner can no longer be used. This avoids
creating dangling pointers.

  1. // This function takes ownership of the heap allocated memory
  2. fn destroy_box(c: Box<i32>) {
  3.     println!("Destroying a box that contains {}", c);
  5.     // `c` is destroyed and the memory freed
  6. }
  8. fn main() {
  9.     // _Stack_ allocated integer
  10.     let x = 5u32;
  12.     // *Copy* `x` into `y` - no resources are moved
  13.     let y = x;
  15.     // Both values can be independently used
  16.     println!("x is {}, and y is {}", x, y);
  18.     // `a` is a pointer to a _heap_ allocated integer
  19.     let a = Box::new(5i32);
  21.     println!("a contains: {}", a);
  23.     // *Move* `a` into `b`
  24.     let b = a;
  25.     // The pointer address of `a` is copied (not the data) into `b`.
  26.     // Both are now pointers to the same heap allocated data, but
  27.     // `b` now owns it.
  29.     // Error! `a` can no longer access the data, because it no longer owns the
  30.     // heap memory
  31.     //println!("a contains: {}", a);
  32.     // TODO ^ Try uncommenting this line
  34.     // This function takes ownership of the heap allocated memory from `b`
  35.     destroy_box(b);
  37.     // Since the heap memory has been freed at this point, this action would
  38.     // result in dereferencing freed memory, but it's forbidden by the compiler
  39.     // Error! Same reason as the previous Error
  40.     //println!("b contains: {}", b);
  41.     // TODO ^ Try uncommenting this line
  42. }