Ownership and scope in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is ownership in Rust?

Ownership is a set of rules that governs how Rust manages memory. Each value in Rust has a variable called its owner, and there can only be one owner at a time.

beginner

What happens when the owner of a value goes out of scope?

When the owner goes out of scope, Rust automatically calls the drop function to free the memory. This prevents memory leaks.

beginner

Explain scope in Rust.

Scope is the area in the code where a variable is valid. When the program execution leaves this area, the variable is no longer accessible.

beginner

Can two variables own the same data at the same time in Rust?

No. Rust enforces that only one variable can own a piece of data at a time to avoid conflicts and bugs.

intermediate

What is the difference between move and copy in Rust ownership?

Move transfers ownership from one variable to another, invalidating the first. Copy duplicates the data, so both variables own their own copy.

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

A It is copied to another variable

B It becomes a global variable

C Its memory is automatically freed

D Nothing happens

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

Which statement is true about ownership in Rust?

A Only one variable can own data at a time

B Ownership only applies to integers

C Ownership is optional in Rust

D Multiple variables can own the same data simultaneously

Rust enforces that only one variable owns a piece of data at a time to ensure safety.

What does the move keyword do in Rust?

A Transfers ownership to a new variable

B Copies data to a new variable

C Deletes the data

D Creates a reference

move transfers ownership from one variable to another, invalidating the original.

If a variable is copied instead of moved, what happens?

A The original variable is invalidated

B The program crashes

C Ownership is lost

D Both variables own separate copies

Copying duplicates the data so both variables have their own independent copies.

What is the scope of a variable?

A The lifetime of the program

B The area in code where the variable is valid

C The memory address of the variable

D The type of the variable

Scope defines where in the code a variable can be accessed.

Describe how ownership and scope work together to manage memory in Rust.

Think about how Rust knows when to free memory safely.

Explain the difference between moving and copying data in Rust ownership.

Consider what happens to the original variable in each case.

Practice

1. What does ownership in Rust primarily ensure?

easy

A. Ownership is not related to variable scope

B. Multiple variables can own the same value simultaneously

C. Variables can share ownership without restrictions

D. Only one variable owns a value at a time

Solution

1. Step 1: Understand ownership concept

   Ownership means a value has exactly one owner variable at any time.

2. Step 2: Compare options with ownership rule

   Only one variable owns a value at a time states single ownership, others allow multiple owners or unrelated concepts.

3. Final Answer:

   Only one variable owns a value at a time -> Option D

4. Quick Check:

   Ownership = single owner [OK]

Hint: Ownership means one owner per value, no sharing [OK]

Common Mistakes:

• Thinking multiple variables can own the same value
• Confusing ownership with borrowing
• Ignoring the role of scope in ownership

2. Which of the following is the correct way to declare a variable with ownership in Rust?

easy

A. let x = String::from("hello");

B. var x = "hello";

C. int x = 5;

D. let x := "hello";

Solution

1. Step 1: Identify Rust variable declaration syntax

   Rust uses 'let' keyword and type inference or explicit types.

2. Step 2: Check each option for Rust syntax

   let x = String::from("hello"); uses 'let' and String::from correctly; others use invalid syntax for Rust.

3. Final Answer:

   let x = String::from("hello"); -> Option A

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust variables start with 'let' keyword [OK]

Common Mistakes:

• Using 'var' instead of 'let'
• Using ':=' which is not Rust syntax
• Declaring types like 'int' which is not Rust

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

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

medium

A. hello

B. Runtime error

C. Compile-time error

D. hellohello

Solution

1. Step 1: Understand ownership move in assignment

   Assigning s1 to s2 moves ownership; s1 is no longer valid.

2. Step 2: Check usage of s1 after move

   Using s1 in println! after move causes compile-time error due to invalid ownership.

3. Final Answer:

   Compile-time error -> Option C

4. Quick Check:

   Using moved value = compile error [OK]

Hint: Using moved variable causes compile error [OK]

Common Mistakes:

• Assuming s1 still owns the value after move
• Expecting runtime error instead of compile error
• Thinking both s1 and s2 own the value

4. Identify the error in this Rust code snippet:

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

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

medium

A. Using s after ownership moved to function

B. Missing semicolon after println!

C. Function takes_ownership should return String

D. String::from is invalid syntax

Solution

1. Step 1: Analyze ownership transfer to function

   Passing s to takes_ownership moves ownership to function parameter.

2. Step 2: Check usage of s after function call

   Using s in println! after move causes compile-time error because s is invalid.

3. Final Answer:

   Using s after ownership moved to function -> Option A

4. Quick Check:

   Use after move = error [OK]

Hint: Ownership moves into function, original variable invalid after [OK]

Common Mistakes:

• Thinking function parameter borrows instead of takes ownership
• Expecting runtime error instead of compile-time
• Ignoring ownership rules with function calls

5. Given this Rust code, what is the correct way to allow main to use s after passing it to takes_ownership?

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

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

hard

A. Return the String from takes_ownership and assign back in main

B. All of the above

C. Clone s before passing: takes_ownership(s.clone())

D. Change takes_ownership to borrow: fn takes_ownership(some_string: &String)

Solution

1. Step 1: Understand ownership transfer problem

   Passing s moves ownership, so s is invalid after call.

2. Step 2: Review options to keep s usable

   Change takes_ownership to borrow: fn takes_ownership(some_string: &String) borrows s, so ownership not moved. Return the String from takes_ownership and assign back in main returns ownership back. Clone s before passing: takes_ownership(s.clone()) clones s to keep original.

3. Step 3: Confirm all options fix the problem

   All three approaches prevent use-after-move error, so all are correct.

4. Final Answer:

   All of the above -> Option B

5. Quick Check:

   Borrow, return, or clone fixes ownership [OK]

Hint: Borrow, return ownership, or clone to keep variable usable [OK]

Common Mistakes:

• Thinking only borrowing works
• Ignoring cloning as a solution
• Not returning ownership from function