**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Data Structures: Arrays, Vectors, and Strings **Topic:** Introduction to vectors: creating and manipulating vectors. **Introduction** In the previous topic, we covered working with arrays and slices. While arrays and slices are useful data structures in Rust, they have limitations. Arrays have a fixed size, and slices are simply views into arrays. In this topic, we will introduce vectors, which are dynamic collections of values of the same type. Vectors are one of the most commonly used data structures in Rust, and they are the default choice for dynamic collections. **What are Vectors?** Vectors are data structures that can store a sequence of elements of the same type. They are implemented as a dynamic array, meaning they can grow or shrink as elements are added or removed. Vectors are part of the Rust standard library, and they are defined in the `alloc::vec` module. **Creating Vectors** There are several ways to create vectors in Rust. Here are a few: * **Using the `Vec::new()` function**: ```rust let v: Vec<i32> = Vec::new(); ``` This creates a new, empty vector that can hold `i32` values. * **Using the `vec!` macro**: ```rust let v = vec![1, 2, 3, 4, 5]; ``` This creates a new vector containing the values `1`, `2`, `3`, `4`, and `5`. * **Using iteration**: ```rust let v: Vec<i32> = (0..10).collect(); ``` This creates a new vector containing the numbers from `0` to `9`. **Manipulating Vectors** Vectors provide several methods for manipulating their contents. Here are a few: * **Adding elements**: ```rust let mut v = vec![1, 2, 3]; v.push(4); ``` This adds the value `4` to the end of the vector. * **Removing elements**: ```rust let mut v = vec![1, 2, 3]; let last_element = v.pop().unwrap(); ``` This removes the last element from the vector and returns it. * **Accessing elements**: ```rust let v = vec![1, 2, 3]; let first_element = v[0]; ``` This accesses the first element of the vector. **Other Vector Methods** Vectors provide several other methods for manipulating their contents. Here are a few: * `insert()` - inserts a new element at a specified position * `remove()` - removes an element at a specified position * `sort()` - sorts the elements of the vector * `reverse()` - reverses the order of the elements of the vector **Iterating Over Vectors** Vectors provide several methods for iterating over their elements. Here are a few: * **Using the `iter()` method**: ```rust let v = vec![1, 2, 3]; for element in v.iter() { println!("{}", element); } ``` This iterates over the elements of the vector, printing each one. * **Using the `into_iter()` method**: ```rust let v = vec![1, 2, 3]; for element in v.into_iter() { println!("{}", element); } ``` This iterates over the elements of the vector, consuming the vector itself. **Conclusion** Vectors are a powerful data structure in Rust, and they are widely used in Rust programming. They provide a dynamic collection of elements, and they are easy to manipulate using the various methods provided by the `Vec` type. In the next topic, we will cover string types in Rust, including the `String` and `&str` types. **Exercises** 1. Create a new vector containing the numbers from `0` to `9`. 2. Add the value `10` to the end of the vector. 3. Remove the last element from the vector and print it. 4. Sort the elements of the vector in descending order. **Further Reading** * [The Rust Book: Vectors](https://doc.rust-lang.org/book/ch08-01-vectors.html) * [The Rust Standard Library: `alloc::vec` module](https://doc.rust-lang.org/std/vec/index.html) **Leave a comment below if you have any questions or need help with this topic.** Next topic: **String types in Rust: String and &str.**