Reference usage patterns in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using references?

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

Rust

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

A 15

B Compilation error

C 10

D 5

💡 Hint

Remember that &x creates a reference and *y dereferences it.

The variable y is a reference to x. Dereferencing y gives the value 10, then adding 5 results in 15.

❓ Predict Output

intermediate

What does this Rust code print with mutable references?

Analyze the following Rust code and determine its output.

Rust

fn main() {
    let mut a = 5;
    {
        let b = &mut a;
        *b += 10;
    }
    println!("{}", a);
}

A 15

B 10

C 5

D Compilation error

💡 Hint

Mutable references allow changing the original value.

The mutable reference b adds 10 to a. So a becomes 15.

🔧 Debug

advanced

What error does this Rust code raise?

Examine the code below. What error will the Rust compiler produce?

Rust

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

A No error, prints '5 6'

B Use of moved value `x`

C Cannot assign to `z` because it is not mutable

D Cannot borrow `x` as mutable because it is also borrowed as immutable

💡 Hint

Rust does not allow mutable and immutable references to coexist.

The code tries to create an immutable reference y and a mutable reference z to x at the same time, which Rust forbids.

🧠 Conceptual

advanced

How many references are valid simultaneously in this Rust code?

Given the following Rust code, how many references to data are valid at the same time?

Rust

fn main() {
    let mut data = 100;
    let r1 = &data;
    let r2 = &data;
    println!("{} {}", r1, r2);
    let r3 = &mut data;
    *r3 += 1;
    println!("{}", r3);
}

A Three references are valid simultaneously

B Only one reference is valid at a time

C Two immutable references are valid simultaneously, but no mutable reference at the same time

D Two mutable references are valid simultaneously

💡 Hint

Rust allows multiple immutable references but only one mutable reference at a time.

The code first has two immutable references r1 and r2 valid together. After they are used, a mutable reference r3 is created. Immutable and mutable references cannot coexist.

❓ Predict Output

expert

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

Analyze the output of this Rust program involving nested references and dereferencing.

Rust

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

A 42 Compilation error 42

B 42 42 42

C Compilation error

D 42 42 Compilation error

💡 Hint

Each level of dereferencing unwraps one layer of reference.

r1 is a reference to x. r2 is a reference to r1, so **r2 dereferences twice to get x. r3 is a reference to r2, so ***r3 dereferences three times to get x.

Practice

1. What does the & symbol represent in Rust when used before a variable?

easy

A. A pointer that can be null

B. A mutable reference to the variable, allowing modification

C. A reference to the variable, allowing read-only access without ownership

D. A way to clone the variable's value

Solution

1. Step 1: Understand the meaning of & in Rust

   In Rust, & creates a reference to a value, which means you can read the value without taking ownership.

2. Step 2: Differentiate from mutable references and pointers

   &mut is used for mutable references, and Rust references are never null pointers, so & is not a pointer that can be null.

3. Final Answer:

   A reference to the variable, allowing read-only access without ownership -> Option C

4. Quick Check:

   & means read-only reference [OK]

Hint: Remember: & means read-only reference, &mut means change allowed [OK]

Common Mistakes:

• Confusing & with &mut for mutability
• Thinking & creates a copy of the value
• Assuming & can be null pointer

2. Which of the following is the correct syntax to create a mutable reference to a variable num in Rust?

easy

A. let ref = #

B. let ref = &mut num;

C. let ref = *num;

D. let ref = mut #

Solution

1. Step 1: Recall syntax for mutable references

   In Rust, to create a mutable reference, you use &mut before the variable name.

2. Step 2: Check each option

   let ref = # uses & which is an immutable reference. let ref = *num; uses dereference operator * incorrectly here. let ref = mut # has incorrect syntax order.

3. Final Answer:

   let ref = &mut num; -> Option B

4. Quick Check:

   Mutable reference syntax = &mut [OK]

Hint: Use &mut before variable for mutable reference [OK]

Common Mistakes:

• Using & instead of &mut for mutable references
• Placing mut after & incorrectly
• Using * instead of & for references

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

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

medium

A. 10

B. &10

C. Compilation error

D. Memory address of x

Solution

1. Step 1: Understand the reference y = &x

   Variable y is a reference to x, so it points to the value 10.

2. Step 2: Printing a reference with println!("{}", y)

   Rust automatically dereferences y when printing, so it prints the value 10, not the address or &10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Printing reference prints value [OK]

Hint: Printing &var shows value, not address [OK]

Common Mistakes:

• Expecting &10 to print literally
• Thinking it prints memory address
• Assuming compilation error due to reference

4. Identify the error in this Rust code snippet:

fn main() {
    let mut num = 5;
    let r = #
    *r = 10;
    println!("{}", num);
}

medium

A. Cannot assign to *r because r is an immutable reference

B. num should not be mutable

C. Missing semicolon after *r = 10

D. Cannot print num after referencing

Solution

1. Step 1: Check reference mutability

   Variable r is an immutable reference to num because it is declared as &num, not &mut num.

2. Step 2: Understand assignment through reference

   You cannot assign a new value through an immutable reference. The line *r = 10; causes a compilation error.

3. Final Answer:

   Cannot assign to *r because r is an immutable reference -> Option A

4. Quick Check:

   Immutable reference cannot be used to modify value [OK]

Hint: Use &mut for references if you want to change data [OK]

Common Mistakes:

• Forgetting to use &mut for mutable references
• Thinking mut on variable alone allows mutation through immutable ref
• Ignoring compiler error messages

5. Given a function that takes a mutable reference to a vector and appends a value, which of the following correctly calls the function to add 42 to vec?

fn add_value(v: &mut Vec<i32>) {
    v.push(42);
}

fn main() {
    let mut vec = vec![1, 2, 3];
    // Which call is correct here?
}

hard

A. add_value(&vec);

B. add_value(mut &vec);

C. add_value(vec);

D. add_value(&mut vec);

Solution

1. Step 1: Understand function parameter type

   The function add_value expects a mutable reference &mut Vec<i32>.

2. Step 2: Check how to pass mutable reference

   To pass a mutable reference, the variable must be mutable and passed as &mut vec. Passing &vec is immutable reference, and passing vec moves ownership.

3. Final Answer:

   add_value(&mut vec); -> Option D

4. Quick Check:

   Mutable reference call uses &mut [OK]

Hint: Pass &mut variable to functions needing mutable reference [OK]

Common Mistakes:

• Passing immutable reference when mutable is needed
• Passing ownership instead of reference
• Incorrect syntax like mut &var