Reference usage patterns in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a reference to the variable num.

Rust

let num = 10;
let num_ref = [1]num;
println!("{}", num_ref);

Drag options to blanks, or click blank then click option'

A&

B*

Cref

Dmut

Attempts:

3 left

💡 Hint

Common Mistakes

Using * instead of & to create a reference.

Using ref keyword incorrectly outside of pattern matching.

In Rust, the ampersand & is used to create a reference to a value without taking ownership.

2fill in blank

medium

Complete the code to dereference the reference num_ref and print the value.

Rust

let num = 20;
let num_ref = #
println!("{}", [1]num_ref);

Drag options to blanks, or click blank then click option'

Amut

B&

Cref

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of * to dereference.

Trying to use ref keyword here.

The asterisk * is used to dereference a reference and access the value it points to.

3fill in blank

hard

Fix the error in the code by completing the blank to borrow text as a mutable reference.

Rust

let mut text = String::from("hello");
let text_ref = [1]text;
text_ref.push_str(", world!");
println!("{}", text_ref);

Drag options to blanks, or click blank then click option'

A&

B&mut

C*

Dref

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of &mut when trying to mutate.

Using * which dereferences but does not create a mutable borrow.

To modify the value through a reference, you must borrow it as a mutable reference using &mut.

4fill in blank

hard

Fill both blanks to create an immutable reference and then dereference it to get the value.

Rust

let value = 42;
let ref_value = [1]value;
let original = [2]ref_value;
println!("{}", original);

Drag options to blanks, or click blank then click option'

A&

B*

Cref

D&mut

Attempts:

3 left

💡 Hint

Common Mistakes

Using &mut instead of & for immutable reference.

Not dereferencing the reference before printing.

First, create an immutable reference with &. Then dereference it with * to get the original value.

5fill in blank

hard

Fill all three blanks to create a mutable reference, modify the value, and then print the updated value.

Rust

let mut count = 5;
let count_ref = [1]count;
*[2] = 10;
println!("{}", [3]);

Drag options to blanks, or click blank then click option'

A&mut

Bcount_ref

Ccount

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of &mut for mutable borrow.

Trying to print the reference instead of the original variable.

Create a mutable reference with &mut. Dereference it to assign a new value. Then print the original variable which now holds the updated value.

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