Arrays and Slices

An array is a collection of objects of the same type T, stored in contiguous
memory. Arrays are created using brackets [], and their size, which is known
at compile time, is part of their type signature [T; size].

Slices are similar to arrays, but their size is not known at compile time.
Instead, a slice is a two-word object, the first word is a pointer to the data,
and the second word is the length of the slice. The word size is the same as
usize, determined by the processor architecture eg 64 bits on an x86-64.
Slices can be used to borrow a section of an array, and have the type signature
&[T].

  1. use std::mem;
  3. // This function borrows a slice
  4. fn analyze_slice(slice: &[i32]) {
  5.     println!("first element of the slice: {}", slice[0]);
  6.     println!("the slice has {} elements", slice.len());
  7. }
  9. fn main() {
  10.     // Fixed-size array (type signature is superfluous)
  11.     let xs: [i32; 5] = [1, 2, 3, 4, 5];
  13.     // All elements can be initialized to the same value
  14.     let ys: [i32; 500] = [0; 500];
  16.     // Indexing starts at 0
  17.     println!("first element of the array: {}", xs[0]);
  18.     println!("second element of the array: {}", xs[1]);
  20.     // `len` returns the size of the array
  21.     println!("array size: {}", xs.len());
  23.     // Arrays are stack allocated
  24.     println!("array occupies {} bytes", mem::size_of_val(&xs));
  26.     // Arrays can be automatically borrowed as slices
  27.     println!("borrow the whole array as a slice");
  28.     analyze_slice(&xs);
  30.     // Slices can point to a section of an array
  31.     println!("borrow a section of the array as a slice");
  32.     analyze_slice(&ys[1 .. 4]);
  34.     // Out of bound indexing yields a panic
  35.     println!("{}", xs[5]);
  36. }