Vectors in Rust

Introduction to Vectors in Rust

Hello! Today, we’re going to delve into one of Rust’s most versatile and powerful data structures — vectors . Just as we explored arrays in our previous lesson, vectors also store a collection of elements of the same type. However, unlike arrays, vectors are dynamic and can grow and shrink as needed. In this lesson, we'll cover the essentials of creating, modifying, and managing vectors in Rust. We’ll look into different ways of creating vectors, adding and removing elements, and understanding how Rust handles data and ownership within vectors. By the end of this lesson, you'll have a strong grasp of vectors and be ready to use them effectively in your Rust programs. Let's get started!

Creating Vectors

Vectors can be created in Rust with or without specifying the data type explicitly. If the type is not explicitly mentioned, Rust will infer it based on the values pushed into the vector. To declare a new vector explicitly use Vec followed by the data type within <>. To add new elements to a vector, use push to append the new value to the end of the vector. To implicitly declare a vector, use vec! followed by the elements inside brackets. Here are a couple of examples to illustrate this: Rustfn main() { // Creating Vector with Data Type let mut vector_with_type: Vec<i32> = Vec::new(); vector_with_type.push(1); vector_with_type.push(2); vector_with_type.push(3); // Creating Vector without Data Type (type inference) let mut vector_without_type = vec![4, 5, 6]; vector_without_type.push(7); } In this example: vector_with_type is explicitly typed as a vector of i32 values. Elements are pushed into the vector using the push method. vector_without_type uses type inference, determining the type from the initial values provided.

Accessing Elements of a Vector

You can access elements of a vector using both the get method and direct indexing. The get method returns an Option type that can be used to handle out-of-bounds errors gracefully. The get method returns an Option<&T> where T is the type of the elements in the vector. The Option type can be Some(&element) if the index is valid, or None if the index is out of bounds. To ensure the valid access of an element, use the pattern matching construct if let Some(&element) = vector.get(index). If index is indeed a valid index, element takes on the value of the element in the vector, and the if block is executed. If index is not a valid index, element takes on the value of None, and the if block does not execute. Rustfn main() { let vector = vec![1, 2, 3]; if let Some(first_elem) = vector.get(0) { println!("First element (using get): {:?}", first_elem); // Prints: First element (using get): 1 } println!("Second element (using index): {}", vector[1]); // Prints: Second element (using index): 2 } If 0 is a valid index of vector (it is), vector.get(0) returns Some(&first_elem) and binds first_elem to the value of the first element of vector. The if block is executed because Some(first_elem) is not None. vector[1] directly accesses the second element but can panic if the index is out-of-bounds.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Ownership and Copy Data in Vectors

Handling ownership and the concept of copy versus non-copy data types is crucial in Rust. Vectors themselves are not Copy types in Rust. Even if the elements inside the vector are of a type that implements the Copy trait (such as i32), the vector itself does not implement the Copy trait. Like arrays, using direct indexing on a vector (vector[index]) does not move ownership of a non-copy element. You can only create a reference to the element. Here's how it works with vectors:

Rust

fn main() {
    let vector_with_copy = vec![1, 2, 3, 4];
    
    // Copy data
    let first_elem_copy = vector_with_copy[0];
    println!("first_elem_copy: {}", first_elem_copy); // Prints: first_elem_copy: 1
    println!("vector_with_copy: {:?}", vector_with_copy); // Prints: vector_with_copy: [1, 2, 3, 4]

    // Non-copy data
    let vector_with_non_copy = vec![String::from("Hello"), String::from("World")];

    let first_elem_non_copy = &vector_with_non_copy[0]; // Creates a reference
    println!("first_elem_non_copy: {}", first_elem_non_copy); // Prints: first_elem_non_copy: Hello
    let invalid_copy = vector_with_non_copy[0]; // Causes an error. You cannot move ownership of vector elements

    // Ownership Transfer
    let copied_vector = vector_with_copy; // Ownership moved to copied_vector
    println!("vector_with_copy: {:?}", vector_with_copy); // Causes an error
}

fn main() {
    let vector_with_copy = vec![1, 2, 3, 4];
    
    // Copy data
    let first_elem_copy = vector_with_copy[0];
    println!("first_elem_copy: {}", first_elem_copy); // Prints: first_elem_copy: 1
    println!("vector_with_copy: {:?}", vector_with_copy); // Prints: vector_with_copy: [1, 2, 3, 4]

    // Non-copy data
    let vector_with_non_copy = vec![String::from("Hello"), String::from("World")];

    let first_elem_non_copy = &vector_with_non_copy[0]; // Creates a reference
    println!("first_elem_non_copy: {}", first_elem_non_copy); // Prints: first_elem_non_copy: Hello
    let invalid_copy = vector_with_non_copy[0]; // Causes an error. You cannot move ownership of vector elements

    // Ownership Transfer
    let copied_vector = vector_with_copy; // Ownership moved to copied_vector
    println!("vector_with_copy: {:?}", vector_with_copy); // Causes an error
}

Vector with Copy Data

vector_with_copy contains i32 elements, which are copy types.
vector_with_copy[0] accesses the first element, 1, which is of type i32.
first_elem_copy is assigned the value 1. Since i32 implements the Copy trait, the value is copied rather than moved.

Vector with Non-Copy Data

vector_with_non_copy is initialized with String elements. String does not implement the Copy trait.
The line &vector_with_non_copy[0] creates a reference to the first element of the vector
The line vector_with_non_copy[0] causes an error because you cannot move ownership of elements in a non-Copy vector

Ownership Transfer

Ownership of vector_with_copy is moved to copied_vector, making vector_with_copy invalid.

Vectors as Function Parameters

Vectors can be passed to functions by reference or by value, affecting ownership and data access. The rules for passing vectors to functions are as follows:

Passing a reference to an vector does not transfer ownership.
Unlike arrays, passing a vector by value always transfers ownership, regardless of whether the elements implement the Copy trait or not.

Rust

fn main() {
    let vector1 = vec![String::from("Hello"), String::from("World")];
    display_vector_reference(&vector1);
    println!("After display_vector_reference: {:?}", vector1); // Prints: After display_vector_reference: ["Hello", "World"]

    let vector2 = vec![1, 2, 3, 4];
    display_vector_ownership(vector2);
    println!("After display_vector_ownership: {:?}", vector2); // Error as ownership has been moved
}

fn display_vector_reference(vec: &Vec<String>) {
    println!("In display_vector_reference: {:?}", vec); // Prints: In display_vector_reference: ["Hello", "World"]
}

fn display_vector_ownership(vec: Vec<i32>) {
    println!("In display_vector_ownership: {:?}", vec); // Prints: In display_vector_ownership: [1, 2, 3, 4]
}

fn main() {
    let vector1 = vec![String::from("Hello"), String::from("World")];
    display_vector_reference(&vector1);
    println!("After display_vector_reference: {:?}", vector1); // Prints: After display_vector_reference: ["Hello", "World"]

    let vector2 = vec![1, 2, 3, 4];
    display_vector_ownership(vector2);
    println!("After display_vector_ownership: {:?}", vector2); // Error as ownership has been moved
}

fn display_vector_reference(vec: &Vec<String>) {
    println!("In display_vector_reference: {:?}", vec); // Prints: In display_vector_reference: ["Hello", "World"]
}

fn display_vector_ownership(vec: Vec<i32>) {
    println!("In display_vector_ownership: {:?}", vec); // Prints: In display_vector_ownership: [1, 2, 3, 4]
}

In this code:

The function display_vector_reference takes a reference to a vector with two String elements. This allows the function to read the vector without taking ownership, so the vector remains available in the main function.
The function display_vector_ownership takes ownership of a vector with two i32 elements. This consumes the vector, making it unavailable for further use in the main function. The last print statement in main causes an error because the vector's ownership has been moved to the function.

Introduction to Vectors in Rust

Creating Vectors

Accessing Elements of a Vector

Join the 1M+ learners on CodeSignal

Modifying Vectors

Removing Elements from a Vector

Ownership and Copy Data in Vectors

Slicing Vectors

Vectors as Function Parameters

Summary and Next Steps