Move semantics in Rust - Mini Project: Build & Apply

Understanding Move Semantics in Rust

📖 Scenario: Imagine you have a box with some toys. You want to give this box to your friend, but once you give it, you no longer have the box. This is like move semantics in Rust, where ownership of data is transferred from one variable to another.

🎯 Goal: You will create a Rust program that shows how moving ownership works. You will start by creating a string, then move it to another variable, and finally try to use the original variable to see what happens.

📋 What You'll Learn

Create a variable with a String value

Create a second variable and move the first variable's value into it

Try to use the first variable after the move

Print the value of the second variable

💡 Why This Matters

🌍 Real World

Move semantics help Rust programs manage memory efficiently and safely, preventing bugs like double frees or use-after-free errors.

💼 Career

Understanding move semantics is essential for Rust developers working on systems programming, embedded devices, or performance-critical applications.

1

Create a String variable

Create a variable called greeting and set it to the string "Hello, Rust!".

Rust

# Create a variable called greeting with the value "Hello, Rust!"
# Your code here

Hint

Use String::from to create a String from a text.

2

Move the String to a new variable

Create a variable called new_owner and move the value of greeting into it by assigning new_owner = greeting.

Rust

fn main() {
    let greeting = String::from("Hello, Rust!");
    
    // Move greeting into new_owner
    // Your code here
}

Hint

Assign greeting to new_owner to move ownership.

3

Try to use the original variable after move

Add a line to print new_owner using println!("{}", new_owner);. Then add a line to print greeting using println!("{}", greeting); to see what error Rust gives.

Rust

fn main() {
    let greeting = String::from("Hello, Rust!");
    let new_owner = greeting;
    
    // Print new_owner
    // Your code here
    
    // Print greeting
    // Your code here
}

Hint

Print both variables to see that greeting cannot be used after the move.

4

Print the moved value only

Remove or comment out the line that prints greeting. Then run the program to print only new_owner.

Rust

fn main() {
    let greeting = String::from("Hello, Rust!");
    let new_owner = greeting;
    
    // Print new_owner only
    // Your code here
}

Hint

Only print new_owner because greeting is no longer valid.

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