Reference usage patterns in Rust

Introduction

References let you use data without taking ownership. This helps share data safely and avoid copying.

When you want to read data without changing it.

When you want to pass large data to a function without copying it.

When you want to allow multiple parts of code to access the same data safely.

When you want to modify data inside a function and keep changes outside.

When you want to avoid moving ownership but still use the value.

Syntax

Rust

let ref_variable = &value; // immutable reference
let mut_ref_variable = &mut value; // mutable reference

Use & to create an immutable reference (read-only).

Use &mut to create a mutable reference (allows changes).

Examples

This creates an immutable reference to x and prints its value.

Rust

let x = 5;
let r = &x; // r is a reference to x
println!("{}", r);

This creates a mutable reference to x, changes the value through the reference, and prints the updated value.

Rust

let mut x = 10;
let r = &mut x; // mutable reference
*r += 5;
println!("{}", x);

Passing an immutable reference to a function to read the value without taking ownership.

Rust

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

let num = 7;
print_value(&num);

Passing a mutable reference to a function to modify the original value.

Rust

fn add_one(val: &mut i32) {
    *val += 1;
}

let mut num = 3;
add_one(&mut num);
println!("{}", num);

Sample Program

This program shows how to create immutable and mutable references. It first prints the original value, then updates it through a mutable reference and prints the new value.

Rust

fn main() {
    let mut score = 42;
    {
        let score_ref = &score; // immutable reference
        println!("Score is {}", score_ref);
    }
    let score_mut_ref = &mut score; // mutable reference
    *score_mut_ref += 8;
    println!("Updated score is {}", score);
}

Important Notes

You cannot have mutable and immutable references to the same data at the same time.

References help avoid copying large data and keep your program efficient.

Use * to access or change the value a reference points to.

Summary

References let you use data without taking ownership.

Use & for read-only access and &mut for changing data.

References help write safe and efficient Rust code.

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