Adding elements to vectors in Rust - Step-by-Step Execution

Concept Flow - Adding elements to vectors

Start with empty vector

↓

Add element using push()

↓

Vector grows by 1 element

↓

Repeat push() as needed

↓

Use vector with new elements

↓

End

Start with an empty vector, add elements one by one using push(), and the vector grows dynamically.

Execution Sample

Rust

let mut v = Vec::new();
v.push(10);
v.push(20);
println!("{:?}", v);

Create an empty vector, add two numbers, then print the vector.

Execution Table

Step	Action	Vector Content	Output
1	Create empty vector	[]
2	Push 10	[10]
3	Push 20	[10, 20]
4	Print vector	[10, 20]	[10, 20]

💡 All push operations done, vector printed, program ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
v	[]	[10]	[10, 20]	[10, 20]

Key Moments - 2 Insights

Why do we need to declare the vector as mutable with 'mut'?

Because push() changes the vector by adding elements, Rust requires 'mut' to allow modification, as shown in step 2 and 3 of the execution_table.

What happens if we try to push elements without 'mut'?

The code will not compile because Rust prevents changing immutable variables. The execution_table shows push() steps require vector to be mutable.

Visual Quiz - 3 Questions

Look at the execution_table, what is the vector content after step 3?

A [10]

B [20]

C [10, 20]

D []

💡 Hint

Check the 'Vector Content' column at step 3 in the execution_table.

At which step is the vector printed to the output?

A Step 4

B Step 2

C Step 1

D Step 3

💡 Hint

Look for the 'Print vector' action in the execution_table.

If we remove 'mut' from the vector declaration, what will happen?

A The program will print an empty vector.

B The code will not compile due to immutability error.

C The vector will still add elements successfully.

D The vector will contain default values.

💡 Hint

Refer to the key_moments about why 'mut' is needed for push() to work.

Concept Snapshot

Create a mutable vector with Vec::new().
Add elements using push(value).
Vector grows dynamically.
Must declare vector as mutable to modify it.
Print vector with println!("{:?}", vector).

Full Transcript

This example shows how to add elements to a vector in Rust. We start by creating an empty vector with Vec::new() and declare it mutable using 'mut' so we can change it. Then we add elements 10 and 20 using the push() method. Each push adds one element to the vector, growing it. Finally, we print the vector to see its contents. The execution table traces each step, showing the vector's content after each push and the output when printed. Remember, without 'mut', Rust will not allow push() because it changes the vector. This step-by-step trace helps understand how vectors grow and how push() works in Rust.

Practice

1. What does the push method do when used on a Rust vector?

easy

A. Removes the last element from the vector

B. Adds a new element to the end of the vector

C. Creates a new vector with one element

D. Sorts the elements in the vector

Solution

1. Step 1: Understand the purpose of push

   The push method is used to add elements to a vector in Rust.

2. Step 2: Identify what push does specifically

   It adds a new element to the end of the vector, increasing its size by one.

3. Final Answer:

   Adds a new element to the end of the vector -> Option B

4. Quick Check:

   push adds element [OK]

Hint: Remember: push always adds at the end [OK]

Common Mistakes:

• Confusing push with pop (which removes elements)
• Thinking push creates a new vector
• Assuming push sorts the vector

2. Which of the following is the correct way to declare a mutable vector and add the number 10 to it in Rust?

easy

A. let v = Vec::new(); v.add(10);

B. let v = Vec::new(); v.push(10);

C. let mut v = Vec::new(); v.add(10);

D. let mut v = Vec::new(); v.push(10);

Solution

1. Step 1: Check vector mutability

   To add elements, the vector must be mutable, so let mut v is required.

2. Step 2: Use correct method to add element

   The method to add an element is push, not add.

3. Final Answer:

   let mut v = Vec::new(); v.push(10); -> Option D

4. Quick Check:

   Mutable vector + push method [OK]

Hint: Mutable vector + push method adds elements [OK]

Common Mistakes:

• Forgetting to make the vector mutable
• Using a non-existent method like add
• Trying to push on an immutable vector

3. What will be the output of this Rust code?

let mut v = vec![1, 2];
v.push(3);
println!("{:?}", v);

medium

A. [1, 2]

B. Compilation error

C. [1, 2, 3]

D. [3, 1, 2]

Solution

1. Step 1: Understand initial vector content

   The vector starts with elements [1, 2].

2. Step 2: Apply the push method

   The push(3) adds 3 at the end, so vector becomes [1, 2, 3].

3. Final Answer:

   [1, 2, 3] -> Option C

4. Quick Check:

   push adds element at end [OK]

Hint: push adds element at the end of vector [OK]

Common Mistakes:

• Expecting push to add at the start
• Thinking push replaces elements
• Assuming code causes error

4. Identify the error in this Rust code snippet:

let v = Vec::new();
v.push(5);

medium

A. Vector is not mutable, so push cannot be called

B. push method does not exist for vectors

C. Vec::new() cannot create an empty vector

D. Missing semicolon after Vec::new()

Solution

1. Step 1: Check vector mutability

   The vector is declared as immutable with let v, so it cannot be changed.

2. Step 2: Understand push method requirements

   The push method requires the vector to be mutable to add elements.

3. Final Answer:

   Vector is not mutable, so push cannot be called -> Option A

4. Quick Check:

   push needs mutable vector [OK]

Hint: Make vector mutable to use push [OK]

Common Mistakes:

• Assuming push works on immutable vectors
• Thinking Vec::new() is invalid
• Ignoring mut keyword necessity

5. You want to add multiple elements [4, 5, 6] to an existing mutable vector v. Which code correctly adds all these elements efficiently?

hard

A. v.extend([4, 5, 6]);

B. v.push(4, 5, 6);

C. v.add([4, 5, 6]);

D. v.push([4, 5, 6]);

Solution

1. Step 1: Understand adding multiple elements

   Using push adds one element at a time, so multiple calls are needed for multiple elements.

2. Step 2: Use the efficient method for multiple elements

   The extend method adds all elements from an iterable at once, which is more efficient.

3. Final Answer:

   v.extend([4, 5, 6]); -> Option A

4. Quick Check:

   Use extend for multiple elements [OK]

Hint: Use extend to add many elements at once [OK]

Common Mistakes:

• Using push with a whole array (causes error)
• Using non-existent add method
• Calling push multiple times instead of extend