Vectors

Vectors are re-sizable arrays. Like slices, their size is not known at compile
time, but they can grow or shrink at any time. A vector is represented using
3 words: a pointer to the data, its length, and its capacity. The capacity
indicates how much memory is reserved for the vector. The vector can grow as
long as the length is smaller than the capacity. When this threshold needs to
be surpassed, the vector is reallocated with a larger capacity.

  1. fn main() {
  2.     // Iterators can be collected into vectors
  3.     let collected_iterator: Vec<i32> = (0..10).collect();
  4.     println!("Collected (0..10) into: {:?}", collected_iterator);
  6.     // The `vec!` macro can be used to initialize a vector
  7.     let mut xs = vec![1i32, 2, 3];
  8.     println!("Initial vector: {:?}", xs);
  10.     // Insert new element at the end of the vector
  11.     println!("Push 4 into the vector");
  12.     xs.push(4);
  13.     println!("Vector: {:?}", xs);
  15.     // Error! Immutable vectors can't grow
  16.     collected_iterator.push(0);
  17.     // FIXME ^ Comment out this line
  19.     // The `len` method yields the current size of the vector
  20.     println!("Vector size: {}", xs.len());
  22.     // Indexing is done using the square brackets (indexing starts at 0)
  23.     println!("Second element: {}", xs[1]);
  25.     // `pop` removes the last element from the vector and returns it
  26.     println!("Pop last element: {:?}", xs.pop());
  28.     // Out of bounds indexing yields a panic
  29.     println!("Fourth element: {}", xs[3]);
  30.     // FIXME ^ Comment out this line
  32.     // `Vector`s can be easily iterated over
  33.     println!("Contents of xs:");
  34.     for x in xs.iter() {
  35.         println!("> {}", x);
  36.     }
  38.     // A `Vector` can also be iterated over while the iteration
  39.     // count is enumerated in a separate variable (`i`)
  40.     for (i, x) in xs.iter().enumerate() {
  41.         println!("In position {} we have value {}", i, x);
  42.     }
  44.     // Thanks to `iter_mut`, mutable `Vector`s can also be iterated
  45.     // over in a way that allows modifying each value
  46.     for x in xs.iter_mut() {
  47.         *x *= 3;
  48.     }
  49.     println!("Updated vector: {:?}", xs);
  50. }

More Vec methods can be found under the
std::vec module