Ownership rules in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of ownership rules in Rust?

Ownership rules help Rust manage memory safely without a garbage collector by ensuring each value has a single owner responsible for cleaning it up.

beginner

Explain the rule: "Each value in Rust has a variable that’s called its owner."

This means every piece of data is owned by exactly one variable at a time, which controls the data’s lifetime and cleanup.

beginner

What happens when the owner variable goes out of scope?

Rust automatically calls the `drop` function to free the memory of the owned value, preventing memory leaks.

intermediate

What does it mean to "move" ownership in Rust?

Moving ownership means transferring the responsibility of a value from one variable to another, invalidating the original owner to avoid double free errors.

intermediate

Why does Rust prevent multiple owners for the same data by default?

To avoid data races and ensure memory safety by making sure only one variable can modify or free the data at a time.

What happens when a variable owning a value goes out of scope in Rust?

A Nothing happens; memory must be freed manually.

B The value is copied to a new variable.

C The value is automatically dropped and memory freed.

D The program crashes.

Rust automatically frees memory when the owner variable goes out of scope to prevent leaks.

Which of the following best describes ownership in Rust?

A Multiple variables can own the same value simultaneously.

B Ownership is optional and only used for performance.

C Ownership means copying data automatically.

D Each value has exactly one owner at a time.

Rust enforces that each value has exactly one owner to ensure safe memory management.

What does moving ownership do to the original variable?

A Leaves it unchanged and valid.

B Invalidates it so it can no longer be used.

C Copies the value to the original variable.

D Duplicates the ownership.

After moving ownership, the original variable is invalidated to prevent double free errors.

Why does Rust not allow multiple owners by default?

A To avoid data races and memory errors.

B To make code shorter.

C Because Rust does not support references.

D To improve program speed.

Single ownership prevents data races and ensures memory safety.

Which of these is NOT part of Rust's ownership rules?

A Values can have multiple mutable owners at once.

B When the owner goes out of scope, the value is dropped.

C Each value has a single owner.

D Ownership can be transferred by moving.

Rust does not allow multiple mutable owners to prevent unsafe memory access.

Describe the three main ownership rules in Rust and why they matter.

Think about how Rust manages memory without a garbage collector.

Explain what happens when ownership is moved from one variable to another in Rust.

Consider what Rust does to avoid using old variables after move.

Practice

1. What happens when ownership of a variable is moved to another variable in Rust?

easy

A. The original variable becomes invalid and cannot be used.

B. Both variables can be used independently without restrictions.

C. The data is copied and both variables own separate copies.

D. The original variable automatically deletes the data.

Solution

1. Step 1: Understand ownership move

   When ownership moves, the original variable loses its right to access the data.

2. Step 2: Effect on original variable

   The original variable becomes invalid and cannot be used to prevent double free errors.

3. Final Answer:

   The original variable becomes invalid and cannot be used. -> Option A

4. Quick Check:

   Ownership move invalidates old owner = A [OK]

Hint: Ownership move disables old variable usage [OK]

Common Mistakes:

• Thinking ownership move copies data
• Assuming both variables remain valid
• Confusing move with borrowing

2. Which of the following is the correct syntax to borrow a variable immutably in Rust?

easy

A. let ref x = value;

B. let x = value;

C. let x = *value;

D. let x = &value;

Solution

1. Step 1: Identify borrowing syntax

   Immutable borrowing uses the & symbol before the variable.

2. Step 2: Match correct syntax

   let x = &value; correctly borrows value immutably.

3. Final Answer:

   let x = &value; -> Option D

4. Quick Check:

   Immutable borrow uses & = B [OK]

Hint: Use & to borrow immutably [OK]

Common Mistakes:

• Using * for borrowing instead of dereferencing
• Missing & symbol for borrowing
• Confusing mutable and immutable borrow syntax

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

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);

medium

A. Runtime error

B. hello

C. Compilation error

D. Empty string

Solution

1. Step 1: Analyze ownership move

   Assigning s1 to s2 moves ownership, invalidating s1.

2. Step 2: Using invalidated variable

   Printing s1 after move causes a compile-time error because s1 is no longer valid.

3. Final Answer:

   Compilation error -> Option C

4. Quick Check:

   Using moved variable causes compile error = A [OK]

Hint: Using moved variable causes compile error [OK]

Common Mistakes:

• Expecting s1 to print after move
• Confusing move with copy
• Thinking runtime error occurs instead

4. Identify the error in this Rust code snippet:

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

medium

A. No error, code runs fine.

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

C. String::from is not a valid function.

D. Cannot print two variables in one println! macro.

Solution

1. Step 1: Check borrowing rules

   Rust forbids mutable borrow if immutable borrow exists simultaneously.

2. Step 2: Identify conflict

   r1 is an immutable borrow; r2 tries mutable borrow causing error.

3. Final Answer:

   Cannot borrow s as mutable because it is already borrowed as immutable. -> Option B

4. Quick Check:

   Mutable borrow conflicts with existing immutable borrow = D [OK]

Hint: Mutable borrow disallowed if immutable borrow exists [OK]

Common Mistakes:

• Ignoring borrow rules and expecting code to run
• Thinking multiple mutable borrows allowed
• Misunderstanding println! macro usage

5. Given this Rust function:

fn take_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    println!("{}", s);
}

What is the correct way to fix the error without cloning the string?

hard

A. Change the function parameter to borrow the string: fn take_ownership(s: &String)

B. Remove the println! after the function call.

C. Declare s as mutable in main.

D. Use let s = &String::from("hello"); in main.

Solution

1. Step 1: Understand ownership transfer

   Passing s to take_ownership moves ownership, invalidating s in main.

2. Step 2: Use borrowing to avoid move

   Changing parameter to &String borrows s, so ownership stays with main.

3. Step 3: Adjust function call

   Call take_ownership(&s) to pass reference matching new parameter.

4. Final Answer:

   Change the function parameter to borrow the string: fn take_ownership(s: &String) -> Option A

5. Quick Check:

   Borrow parameter to keep ownership in caller = C [OK]

Hint: Borrow in function parameter to keep ownership [OK]

Common Mistakes:

• Trying to use s after move without borrowing
• Removing code instead of fixing ownership
• Confusing mutability with ownership