Ownership and scope in Rust - Mini Project: Build & Apply

Understanding Ownership and Scope in Rust

📖 Scenario: Imagine you are managing a small library of books in a Rust program. Each book has a title stored as a string. You want to understand how Rust handles ownership and scope when you create and use these book titles.

🎯 Goal: You will create a string variable for a book title, then move ownership to another variable inside a smaller scope, and finally observe what happens when the scope ends.

📋 What You'll Learn

Create a string variable called book_title with the value "The Rust Book".

Create a new scope using curly braces { }.

Inside the new scope, move ownership of book_title to a new variable called title_in_scope.

Print title_in_scope inside the scope.

Try to print book_title after the scope ends and observe the compiler error.

💡 Why This Matters

🌍 Real World

Understanding ownership and scope is essential in Rust to manage memory safely without a garbage collector.

💼 Career

Rust developers must master ownership rules to write efficient and safe code, especially in systems programming and performance-critical applications.

1

Create the initial string variable

Create a string variable called book_title and set it to String::from("The Rust Book").

Rust

# Create a string variable called book_title with the value "The Rust Book"
# Your code here

Hint

Use let to create a variable and String::from to create a string.

2

Create a new scope and move ownership

Add a new scope using { }. Inside this scope, move ownership of book_title to a new variable called title_in_scope by assigning title_in_scope = book_title.

Rust

fn main() {
    let book_title = String::from("The Rust Book");
    {
        // Move ownership of book_title to title_in_scope
        // Your code here
    }
}

Hint

Use curly braces to create a new scope and assign book_title to title_in_scope.

3

Print the variable inside the scope

Inside the scope, add a println! statement to print title_in_scope.

Rust

fn main() {
    let book_title = String::from("The Rust Book");
    {
        let title_in_scope = book_title;
        // Print title_in_scope here
        // Your code here
    }
}

Hint

Use println!("{}", variable) to print a string variable.

4

Try to print the original variable after the scope

After the scope ends, add a println! statement to print book_title. Run the program and observe the compiler error about ownership.

Rust

fn main() {
    let book_title = String::from("The Rust Book");
    {
        let title_in_scope = book_title;
        println!("{}", title_in_scope);
    }
    // Try to print book_title here
    // Your code here
}

Hint

Try to print book_title after the scope to see the ownership error.

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