Immutable references in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using immutable references?

Consider the following Rust code snippet. What will it print?

Rust

fn main() {
    let x = 10;
    let y = &x;
    let z = &x;
    println!("{} {}", y, z);
}

A 10 10

B Compilation error due to multiple immutable references

C Runtime error due to borrowing rules

D 0 0

💡 Hint

Remember, Rust allows multiple immutable references at the same time.

Rust permits multiple immutable references simultaneously because they do not allow mutation. So both y and z point to x safely, printing its value twice.

❓ Predict Output

intermediate

What error does this Rust code produce?

Analyze the following Rust code. What error will the compiler show?

Rust

fn main() {
    let mut x = 5;
    let y = &x;
    let z = &mut x;
    println!("{} {}", y, z);
}

A prints: 5 5

B error: cannot borrow `x` as immutable because it is also borrowed as mutable

C error: cannot borrow `x` as mutable because it is also borrowed as immutable

D compiles but panics at runtime

💡 Hint

Rust does not allow mutable and immutable references to the same variable at the same time.

The compiler forbids having a mutable reference while immutable references exist. Here, y is an immutable reference and z tries to be mutable simultaneously, causing a compile-time error.

🔧 Debug

advanced

Why does this Rust code fail to compile?

Look at this Rust code snippet. It fails to compile. What is the cause?

Rust

fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = &mut s;
    println!("{} and {}", r1, r2);
}

A No error, prints: hello and hello

B Cannot borrow `s` as immutable because it is already borrowed as mutable

C Use of moved value `s`

D Cannot borrow `s` as mutable because it is already borrowed as immutable

💡 Hint

Check Rust's borrowing rules about mutable and immutable references.

Rust forbids mutable and immutable references to the same variable at the same time. Here, r1 is an immutable reference and r2 tries to be mutable simultaneously, causing a compile-time error.

❓ Predict Output

advanced

What is the output of this Rust code with nested immutable references?

What will this Rust program print?

Rust

fn main() {
    let x = 42;
    let r1 = &x;
    let r2 = &r1;
    println!("{}", **r2);
}

A error: mismatched types

B 42

C prints: &42

D error: cannot dereference twice

💡 Hint

Think about how many layers of references you have and how to access the original value.

r1 is a reference to x, and r2 is a reference to r1. Using **r2 dereferences twice to get the original value 42.

❓ Predict Output

expert

What is the output of this Rust code involving immutable references and shadowing?

Examine the following Rust code. What will it print?

Rust

fn main() {
    let x = 5;
    let x = &x;
    let x = &x;
    println!("{}", ***x);
}

A 5

B error: cannot dereference three times

C error: mismatched types

D prints: &&5

💡 Hint

Consider how shadowing creates multiple layers of references and how many times you need to dereference.

Each let x = &x; creates a new reference to the previous x. The final ***x dereferences three times to get the original value 5.

Practice

1. What does an immutable reference in Rust allow you to do?

easy

A. Prevent any access to the data

B. Read data without changing it

C. Create multiple mutable references

D. Change data while reading it

Solution

1. Step 1: Understand the purpose of immutable references

   Immutable references allow you to look at data without changing it.

2. Step 2: Compare options with this understanding

   Only Read data without changing it correctly states that immutable references let you read data without changing it.

3. Final Answer:

   Read data without changing it -> Option B

4. Quick Check:

   Immutable reference = read-only access [OK]

Hint: Immutable references only allow reading data [OK]

Common Mistakes:

• Thinking immutable references allow data modification
• Confusing mutable and immutable references
• Believing immutable references block all access

2. Which of the following is the correct syntax to create an immutable reference to a variable x in Rust?

easy

A. let ref = x&;

B. let ref = *x;

C. let ref = &mut x;

D. let ref = &x;

Solution

1. Step 1: Recall syntax for immutable references

   In Rust, an immutable reference is created using the ampersand before the variable: &x.

2. Step 2: Check each option

   let ref = &x; uses &x correctly. let ref = *x; uses dereference operator incorrectly. let ref = &mut x; creates a mutable reference, not immutable. let ref = x&; is invalid syntax.

3. Final Answer:

   let ref = &x; -> Option D

4. Quick Check:

   Immutable reference syntax = &variable [OK]

Hint: Use & before variable name for immutable reference [OK]

Common Mistakes:

• Using *x instead of &x
• Confusing mutable (&mut) with immutable (&)
• Writing invalid syntax like x&

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

let x = 10;
let r1 = &x;
let r2 = &x;
println!("{} and {}", r1, r2);

medium

A. Compilation error due to multiple references

B. Runtime error

C. 10 and 10

D. 10 and 0

Solution

1. Step 1: Understand multiple immutable references

   Rust allows multiple immutable references to the same data at the same time without error.

2. Step 2: Check the print statement

   Both r1 and r2 point to x which is 10, so printing them shows "10 and 10".

3. Final Answer:

   10 and 10 -> Option C

4. Quick Check:

   Multiple immutable refs print same value [OK]

Hint: Multiple immutable references can coexist safely [OK]

Common Mistakes:

• Thinking multiple immutable references cause errors
• Expecting runtime errors from references
• Confusing mutable and immutable references rules

4. Identify the error in this Rust code snippet:

let mut x = 5;
let r1 = &x;
let r2 = &mut x;
println!("{} and {}", r1, r2);

medium

A. Cannot have mutable and immutable references at the same time

B. Missing semicolon after let r1

C. Cannot print references directly

D. Variable x should not be mutable

Solution

1. Step 1: Check reference rules in Rust

   Rust forbids having a mutable reference while immutable references exist to the same variable.

2. Step 2: Analyze the code

   Here, r1 is an immutable reference and r2 is a mutable reference to x at the same time, causing a compile error.

3. Final Answer:

   Cannot have mutable and immutable references at the same time -> Option A

4. Quick Check:

   Mutable + immutable refs together = error [OK]

Hint: Mutable and immutable refs can't coexist simultaneously [OK]

Common Mistakes:

• Ignoring Rust's borrowing rules
• Thinking printing references causes error
• Assuming mutability of variable is the problem

5. Given this Rust function:

fn print_value(val: &i32) {
    println!("Value is {}", val);
}

fn main() {
    let mut num = 20;
    let r1 = #
    print_value(r1);
    let r2 = &mut num;
    *r2 += 5;
    print_value(&num);
}

What is the output when this program runs?

hard

A. Value is 20\nValue is 25

B. Compilation error due to mutable and immutable references

C. Value is 25\nValue is 25

D. Runtime error

Solution

1. Step 1: Analyze references in main function

   First, an immutable reference r1 to num is created and passed to print_value. Then a mutable reference r2 is created after r1 is no longer used.

2. Step 2: Check Rust borrowing rules

   Rust allows mutable references after immutable references are no longer used. Here, r1 is used only in print_value, so r2 creation is valid.

3. Step 3: Determine output

   First print_value prints 20, then after incrementing via r2, second print_value prints 25.

4. Final Answer:

   Value is 20 Value is 25 -> Option A

5. Quick Check:

   Immutable ref used before mutable ref creation [OK]

Hint: Mutable ref can be created after immutable ref is no longer used [OK]

Common Mistakes:

• Assuming code runs into compile error
• Ignoring Rust's borrowing rules about scopes
• Thinking mutable ref can coexist with immutable ref simultaneously