Move semantics in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is move semantics in Rust?

Move semantics means transferring ownership of data from one variable to another without copying it. After the move, the original variable can no longer be used.

beginner

What happens to a variable after its value is moved in Rust?

The original variable becomes invalid and cannot be used anymore. Rust prevents using it to avoid bugs.

intermediate

Why does Rust use move semantics instead of copying by default for some types?

Because copying large data can be slow and waste memory. Moving is faster since it just transfers ownership without duplicating data.

intermediate

How can you explicitly clone data instead of moving it in Rust?

You can call the clone() method on the data to create a deep copy, keeping both variables valid.

beginner

Give an example of a type in Rust that implements move semantics by default.

Types like String and Vec move their data by default because they own heap memory. When assigned or passed, ownership moves.

What happens when you assign a String variable to another variable in Rust?

A Rust throws a compile error.

B Data is copied, both variables are valid.

C Ownership moves to the new variable, original is invalid.

D The original variable is cloned automatically.

Assigning a String moves ownership. The original variable cannot be used after the move.

How do you keep both variables valid when assigning a value that implements move semantics?

A Use the <code>clone()</code> method to copy the data.

B Use the <code>copy()</code> method.

C Use <code>let mut</code> keyword.

D You cannot keep both valid.

Calling clone() creates a deep copy, so both variables are valid.

Which of these types does NOT implement move semantics by default in Rust?

A String

B Vec

C Box

D i32

Primitive types like i32 implement the Copy trait, so they are copied, not moved.

Why does Rust prevent using a variable after its value has been moved?

A To avoid double free errors and bugs.

B Because the variable is deleted from memory.

C To save memory space.

D Because the compiler is strict without reason.

Rust enforces ownership rules to prevent bugs like double frees by invalidating moved variables.

What keyword is used in Rust to explicitly copy data instead of moving it?

A copy()

B clone()

C move()

D duplicate()

The clone() method explicitly copies data, creating a new owned instance.

Explain move semantics in Rust and why it is important for memory safety.

Think about how Rust avoids copying large data and keeps programs safe.

Describe how you can keep two variables valid when working with types that use move semantics.

Consider how to make a copy instead of moving ownership.

Practice

1. What happens to a variable in Rust after its value is moved to another variable?

easy

A. The original variable can no longer be used.

B. The original variable keeps a copy of the value.

C. The original variable is automatically cloned.

D. The original variable becomes a reference to the new variable.

Solution

1. Step 1: Understand move semantics

   In Rust, moving a value transfers ownership from one variable to another.

2. Step 2: Effect on original variable

   After the move, the original variable is invalid and cannot be used to prevent double free errors.

3. Final Answer:

   The original variable can no longer be used. -> Option A

4. Quick Check:

   Move means original variable unusable [OK]

Hint: Moving means original variable is invalid after transfer [OK]

Common Mistakes:

• Thinking the original variable still holds a copy
• Assuming Rust automatically clones on move
• Confusing move with borrowing

2. Which of the following Rust code snippets correctly moves ownership of a String from a to b?

easy

A. let b = a.clone();

B. let b = &a;

C. let b = a;

D. let b = *a;

Solution

1. Step 1: Identify move syntax

   Assigning let b = a; moves ownership of a to b.

2. Step 2: Check other options

   &a borrows, a.clone() copies, *a is invalid for String.

3. Final Answer:

   let b = a; -> Option C

4. Quick Check:

   Simple assignment moves ownership [OK]

Hint: Use simple assignment to move ownership, not references or clone [OK]

Common Mistakes:

• Using references instead of moving
• Using clone which copies instead of moves
• Dereferencing a String which is invalid

3. What is the output of this Rust code?

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

medium

A. Compilation error

B. hello

C. Runtime error

D. Empty string

Solution

1. Step 1: Analyze ownership transfer

   Assigning s2 = s1 moves ownership of the String from s1 to s2.

2. Step 2: Using moved variable

   Trying to print s1 after move causes a compile-time error because s1 is invalid.

3. Final Answer:

   Compilation error -> Option A

4. Quick Check:

   Using moved variable causes compile error [OK]

Hint: Using moved variable causes compile error, not runtime [OK]

Common Mistakes:

• Expecting output 'hello' despite move
• Thinking it causes runtime error
• Assuming Rust clones automatically

4. Identify the error in this Rust code related to move semantics:

fn main() {
    let v = vec![1, 2, 3];
    let v2 = v;
    println!("{}", v.len());
}

medium

A. Vector v cannot be moved to v2.

B. Cannot print vector length with println!.

C. Missing semicolon after let v2 = v.

D. Using v.len() after v was moved to v2.

Solution

1. Step 1: Understand move of vector

   Assigning v2 = v moves ownership of vector v to v2.

2. Step 2: Using moved variable causes error

   Calling v.len() after move is invalid and causes compile error.

3. Final Answer:

   Using v.len() after v was moved to v2. -> Option D

4. Quick Check:

   Using moved variable causes compile error [OK]

Hint: After move, original variable cannot be used [OK]

Common Mistakes:

• Thinking vector cannot be moved
• Ignoring ownership rules after move
• Confusing move with borrowing

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 best way to fix the code so main can print s after calling take_ownership?

hard

A. Clone s before passing: take_ownership(s.clone()).

B. All of the above.

C. Return s from take_ownership and assign it back.

D. Change take_ownership to take a reference: fn take_ownership(s: &String).

Solution

1. Step 1: Understand ownership transfer in function

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

2. Step 2: Ways to keep s usable

   Change take_ownership to take a reference: fn take_ownership(s: &String). borrows s so ownership is not moved.
   Clone s before passing: take_ownership(s.clone()). clones s so original remains.
   Return s from take_ownership and assign it back. returns ownership back to main.

3. Step 3: Best fix

   All three options correctly fix the problem.

4. Final Answer:

   All of the above. -> Option B

5. Quick Check:

   Borrow, clone, or return ownership fixes [OK]

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

Common Mistakes:

• Ignoring ownership transfer in function calls
• Not cloning when needed
• Not returning ownership back