Accessing elements in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

How do you access an element at index 2 in a Rust array named arr?

You use square brackets with the index: arr[2]. Remember, Rust arrays are zero-indexed, so this gets the third element.

beginner

What happens if you try to access an index out of bounds in a Rust array?

Rust will panic at runtime with an error message. This is a safety feature to prevent undefined behavior.

intermediate

How can you safely access an element in a Rust vector without risking a panic?

Use the get() method, which returns an Option. For example, vec.get(2) returns Some(&value) if the index exists, or None if it doesn't.

intermediate

What is the difference between arr[2] and arr.get(2) in Rust?

arr[2] directly accesses the element and will panic if out of bounds. arr.get(2) returns an Option, allowing you to handle missing elements safely.

advanced

How do you access a character at a specific position in a Rust string?

Rust strings are UTF-8 encoded, so you can't directly index them. Instead, convert the string to a character iterator and use nth(). For example, my_string.chars().nth(2) returns an Option<char>.

What will happen if you access arr[10] in a Rust array of length 5?

A The program will panic at runtime.

B It will return <code>None</code>.

C It will return a default value.

D It will compile error.

Accessing an out-of-bounds index with [] causes a runtime panic in Rust.

Which method safely accesses an element in a Rust vector?

A <code>vec.safe_index(2)</code>

B <code>vec[2]</code>

C <code>vec.access(2)</code>

D <code>vec.get(2)</code>

get() returns an Option and avoids panics.

How do you access the third character of a Rust string s?

A <code>s.chars().nth(2)</code>

B <code>s.char_at(2)</code>

C <code>s.get(2)</code>

D <code>s[2]</code>

Rust strings can't be indexed directly; use chars().nth() to get characters safely.

What type does vec.get(2) return?

A The element type directly

B Option<&T>

C Result<T, Error>

D None

get() returns Option with a reference to the element.

Why does Rust prevent direct indexing on strings?

A Because strings are immutable

B Because strings are arrays

C Because strings are UTF-8 encoded and indexing could break characters

D Because strings are always empty

UTF-8 encoding means characters can be multiple bytes, so direct indexing is unsafe.

Explain how to safely access elements in Rust arrays and vectors.

Think about how Rust prevents errors when accessing elements.

Describe how to access characters in a Rust string and why direct indexing is not allowed.

Consider how Rust handles multi-byte characters.

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