Accessing elements in Rust - Step-by-Step Execution

Concept Flow - Accessing elements

Start

↓

Create collection

↓

Specify index/key

↓

Access element

↓

Use element (print, assign, etc.)

↓

End

This flow shows how to access an element from a collection by specifying its index or key and then using that element.

Execution Sample

Rust

let numbers = [10, 20, 30];
let first = numbers[0];
println!("{}", first);

This code creates an array, accesses the first element, and prints it.

Execution Table

Step	Action	Expression	Result/Value
1	Create array	let numbers = [10, 20, 30];	[10, 20, 30]
2	Access element at index 0	numbers[0]	10
3	Assign to variable	let first = 10;	10
4	Print value	println!("{}", first);	Outputs: 10

💡 All steps completed, program ends after printing the first element.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
numbers	undefined	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
first	undefined	undefined	undefined	10	10

Key Moments - 2 Insights

Why do we use numbers[0] to get the first element?

In Rust, arrays are zero-indexed, so the first element is at index 0, as shown in step 2 of the execution table.

What happens if we try to access an index that does not exist?

Rust will panic at runtime if you access an index out of bounds. This is not shown here but is important to remember.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'first' after step 3?

A 10

B 20

C undefined

D 30

💡 Hint

Check the 'Assign to variable' row in the execution table where first is set to 10.

At which step does the program print the value 10?

A Step 1

B Step 4

C Step 2

D Step 3

💡 Hint

Look at the 'Print value' action in the execution table.

If we change numbers[0] to numbers[2], what value will 'first' hold after step 3?

A 10

B 20

C 30

D Error

💡 Hint

Check the array values and the index used in the execution table.

Concept Snapshot

Accessing elements in Rust:
- Use square brackets [] with index to get element from array or vector.
- Indexing starts at 0.
- Example: let x = arr[0]; gets first element.
- Accessing invalid index causes runtime panic.
- Use the element by assigning or printing.

Full Transcript

This example shows how to access elements in Rust arrays. First, an array named 'numbers' is created with three values: 10, 20, and 30. Then, the first element is accessed using numbers[0], which gives 10 because Rust arrays start counting at zero. This value is assigned to the variable 'first'. Finally, the program prints the value of 'first', which outputs 10. Remember, trying to access an index outside the array size will cause the program to stop with an error.

Practice

1. In Rust, how do you access the first element of an array named arr?

easy

A. arr[0]

B. arr[1]

C. arr.first()

D. arr.get(1)

Solution

1. Step 1: Understand Rust indexing

   Rust arrays and slices use zero-based indexing, so the first element is at index 0.

2. Step 2: Access the element using square brackets

   Using arr[0] accesses the first element directly.

3. Final Answer:

   arr[0] -> Option A

4. Quick Check:

   First element index = 0 [OK]

Hint: Remember: Rust arrays start at index 0 [OK]

Common Mistakes:

• Using index 1 for the first element
• Confusing .first() with indexing
• Using get(1) which accesses second element

2. Which of the following is the correct syntax to access the third element of a vector v in Rust?

easy

A. v.get[3]

B. v(3)

C. v[3]

D. v[2]

Solution

1. Step 1: Recall zero-based indexing

   The third element is at index 2 because counting starts at zero.

2. Step 2: Use square brackets with index 2

   The correct syntax is v[2] to access the third element.

3. Final Answer:

   v[2] -> Option D

4. Quick Check:

   Third element index = 2 [OK]

Hint: Count from zero: third element is index 2 [OK]

Common Mistakes:

• Using parentheses instead of square brackets
• Using index 3 for third element
• Incorrect method call syntax like get[3]

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

let arr = [10, 20, 30, 40];
println!("{}", arr[1]);

medium

A. 20

B. 40

C. 30

D. 10

Solution

1. Step 1: Identify the array elements and their indexes

   The array arr has elements: 10 at index 0, 20 at index 1, 30 at index 2, and 40 at index 3.

2. Step 2: Access element at index 1

   The code prints arr[1], which is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Index 1 means second element in Rust arrays [OK]

Common Mistakes:

• Printing arr[0] instead of arr[1]
• Confusing index with element value
• Expecting output 30 or 40

4. Consider this Rust code snippet:

let v = vec![1, 2, 3];
let x = v[3];

What is the problem here?

medium

A. Syntax error: wrong vector declaration

B. Index out of bounds panic at runtime

C. Compile-time error: invalid index

D. No problem, x will be 3

Solution

1. Step 1: Check vector size and index used

   The vector v has 3 elements at indexes 0, 1, and 2. Index 3 is out of range.

2. Step 2: Understand Rust's runtime behavior

   Accessing v[3] causes a panic at runtime due to index out of bounds.

3. Final Answer:

   Index out of bounds panic at runtime -> Option B

4. Quick Check:

   Invalid index causes panic [OK]

Hint: Index must be less than vector length [OK]

Common Mistakes:

• Thinking it causes compile error
• Assuming x will be 3
• Ignoring runtime panic possibility

5. You have a nested vector let data = vec![vec![1, 2], vec![3, 4], vec![5, 6]];. How do you access the number 4?

hard

A. data[0][1]

B. data[2][0]

C. data[1][1]

D. data[1][0]

Solution

1. Step 1: Identify the outer and inner indexes

   The outer vector has 3 inner vectors: index 0 is [1, 2], index 1 is [3, 4], index 2 is [5, 6].

2. Step 2: Access the inner element 4

   Within the inner vector at index 1 ([3, 4]), the element 4 is at index 1.

3. Final Answer:

   data[1][1] -> Option C

4. Quick Check:

   Nested access: outer 1, inner 1 = 4 [OK]

Hint: First index outer vec, second index inner vec [OK]

Common Mistakes:

• Mixing up outer and inner indexes
• Using wrong inner index for element 4
• Accessing out-of-range indexes