Day 13b: Adding, Removing, and Accessing Elements in Vectors

Welcome back to Day 12 of our journey through Rust! Today, we’ll focus on the core operations for vectors—adding elements, removing elements, and accessing elements effectively. Vectors are a dynamic data structure, and understanding how to manipulate them efficiently is essential for writing flexible Rust code.

1. Adding Elements to a Vector

The most common way to add elements to a vector is by using the push() method, which appends an element to the end of the vector.

Example of Adding Elements:

fn main() {
    let mut numbers = vec![1, 2, 3];
    numbers.push(4); // Add an element to the end
    numbers.push(5); // Add another element

    println!("Updated vector: {:?}", numbers);
  }

In this example, we use the push() method to add the values 4 and 5 to the vector numbers.

a. Adding Multiple Elements

To add multiple elements to a vector at once, you can use the extend() method.

Example:

fn main() {
    let mut values = vec![10, 20];
    values.extend([30, 40, 50]);

    println!("Extended vector: {:?}", values);
  }

The extend() method adds all the elements from the provided array or another vector to the end of the vector.

2. Removing Elements from a Vector

Vectors provide different methods for removing elements, depending on what you need.

a. Removing the Last Element with pop()

The pop() method removes the last element from a vector and returns it as an Option. If the vector is empty, it returns None.

Example:

fn main() {
    let mut items = vec![10, 20, 30];
    let last_item = items.pop();

    println!("Last item: {:?}", last_item);
    println!("Remaining items: {:?}", items);
  }

In this example, the pop() method removes and returns the last element, 30, leaving [10, 20] in the vector.

b. Removing Elements by Index with remove()

The remove() method removes an element at a specified index, shifting all elements that come after it to the left.

Example:

fn main() {
    let mut colors = vec!["red", "green", "blue"];
    colors.remove(1); // Remove the element at index 1

    println!("Updated colors: {:?}", colors);
  }

Here, remove(1) removes "green", resulting in the vector ["red", "blue"].

3. Accessing Elements in a Vector

Just like arrays, vector elements can be accessed by index, using either direct indexing or the get() method for safe access.

a. Accessing Elements by Index

You can access elements by specifying the index within square brackets. Note that indexing starts at zero.

Example:

fn main() {
    let cities = vec!["London", "Berlin", "Tokyo"];
    let city = &cities[1]; // Access the element at index 1

    println!("City: {}", city);
  }

b. Safe Access with get()

The get() method provides safe access to elements, returning an Option to handle out-of-bounds errors gracefully.

Example:

fn main() {
    let numbers = vec![5, 10, 15];
    match numbers.get(2) {
        Some(&value) => println!("Value: {}", value),
        None => println!("Index out of bounds"),
    }
  }

Using get() ensures that you won’t accidentally access an index that doesn’t exist, preventing runtime panics.

Conclusion

Today, we covered the essential operations for working with vectors in Rust—adding elements, removing elements, and accessing elements safely. Vectors are a powerful data structure due to their dynamic nature, and understanding these operations will help you handle collections of data efficiently in your Rust programs.

In the next post, Day 13c, we’ll explore how to iterate over vectors, borrow them, and create slices from vectors, which will further enhance your ability to work with this flexible data structure.