How do you create and manipulate a vector in Rust

A Vec (short for vector) is a growable array type in Rust that allows you to store a variable number of elements. Vectors are one of the most commonly used collection types in Rust due to their flexibility and ease of use. In this guide, we will explore how to create, manipulate, and access elements in a vector.

1. Creating a Vector

You can create a vector in Rust using the Vec::new() method or by using the vec![] macro.

Example of Creating a Vector


fn main() {
    // Creating an empty vector
    let mut numbers: Vec<i32> = Vec::new();
    // Creating a vector with initial values
    let fruits = vec![`Apple`, `Banana`, `Cherry`];
    println!(`Initial numbers vector: {:?}`, numbers);
    println!(`Fruits vector: {:?}`, fruits);
}
    </i32>

Explanation of the Example

In this example, we create an empty mutable vector named numbers that will hold i32 values.
We also create a vector named fruits using the vec![] macro, which initializes it with three string slices.
The println! macro is used to print the contents of both vectors using the Debug format specifier ?:.

2. Adding Elements to a Vector

You can add elements to a vector using the push method, which appends an element to the end of the vector.

Example of Adding Elements


fn main() {
    let mut numbers = Vec::new();
    // Adding elements to the vector
    numbers.push(10);
    numbers.push(20);
    numbers.push(30);
    println!(`Numbers after adding elements: {:?}`, numbers);
}

Explanation of the Example

In this example, we create a mutable vector named numbers.
We use the push method to add three integers to the vector.
Finally, we print the contents of the vector after adding the elements.

3. Accessing Elements in a Vector

You can access elements in a vector using indexing. Rust uses zero-based indexing, meaning the first element is at index 0.

Example of Accessing Elements


fn main() {
    let fruits = vec![`Apple`, `Banana`, `Cherry`];
    // Accessing elements by index
    let first_fruit = fruits[0];
    let second_fruit = fruits[1];
    println!(`First fruit: {}`, first_fruit);
    println!(`Second fruit: {}`, second_fruit);
}

Explanation of the Example

In this example, we create a vector named fruits with three string slices.
We access the first and second elements using their respective indices and store them in variables first_fruit and second_fruit.
We then print the accessed fruits to the console.

4. Iterating Over a Vector

You can iterate over the elements of a vector using a for loop. This allows you to perform operations on each element in the vector.

Example of Iterating Over a Vector


fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    // Iterating over the vector
    for number in &numbers {
        println!(`Number: {}`, number);
    }
}

Explanation of the Example

In this example, we create a vector named numbers with five integer values.
We use a for loop to iterate over the vector, borrowing each element with &numbers to avoid ownership issues.
Inside the loop, we print each number to the console.

5. Removing Elements from a Vector

You can remove elements from a vector using the pop method, which removes the last element, or the remove method, which allows you to remove an element at a specific index.

Example of Removing Elements


fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];
    // Removing the last element
    numbers.pop();
    // Removing the element at index 1
    numbers.remove(1);
    println!(`Numbers after removal: {:?}`, numbers);
}

Explanation of the Example

In this example, we create a mutable vector named numbers with five integer values.
We use the pop method to remove the last element from the vector.
We then use the remove method to remove the element at index 1.
Finally, we print the contents of the vector after the removals.

6. Conclusion

Vectors in Rust are powerful and flexible collections that allow you to store and manipulate a sequence of elements. By understanding how to create, add, access, iterate, and remove elements from vectors, you can effectively manage data in your Rust programs.