Reference usage patterns in Rust - Mini Project: Build & Apply

Reference Usage Patterns in Rust

📖 Scenario: You are working on a simple Rust program that manages book titles and their lengths. You want to practice using references to avoid copying data unnecessarily.

🎯 Goal: Build a Rust program that stores book titles, uses references to access them, and prints each title with its length.

📋 What You'll Learn

Create a vector of book titles as strings

Create a reference to the vector

Use a for loop with references to iterate over the book titles

Print each book title and its length using references

💡 Why This Matters

🌍 Real World

Using references in Rust helps manage memory efficiently, especially when working with large data like lists of books or documents.

💼 Career

Understanding references is essential for Rust developers to write safe and fast programs, a skill valued in systems programming and backend development.

1

Create a vector of book titles

Create a vector called books with these exact string values: "The Hobbit", "1984", and "Pride and Prejudice".

Rust

# Create a vector called books with the given titles
# Your code here

Hint

Use vec![...] to create a vector with string slices.

2

Create a reference to the vector

Create a reference called books_ref that refers to the books vector.

Rust

let books = vec!["The Hobbit", "1984", "Pride and Prejudice"];
// Create a reference called books_ref to books
# Your code here

Hint

Use & to create a reference to a variable.

3

Iterate over the book titles using references

Use a for loop with book as the loop variable to iterate over books_ref by reference. Inside the loop, get the length of each book using book.len().

Rust

let books = vec!["The Hobbit", "1984", "Pride and Prejudice"];
let books_ref = &books;
// Use a for loop with book to iterate over books_ref by reference
# Your code here

Hint

Use .iter() to get an iterator over references to the vector elements.

4

Print each book title and its length

Inside the for loop, use println! to print the book title and its length in this exact format: "The Hobbit has 10 characters." Use the variables book and length.

Rust

let books = vec!["The Hobbit", "1984", "Pride and Prejudice"];
let books_ref = &books;
for book in books_ref.iter() {
    let length = book.len();
    // Print the book title and length here
# Your code here
}

Hint

Use println!("{} has {} characters.", book, length); to print the message.

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