Ownership and scope in Rust - Step-by-Step Execution

Concept Flow - Ownership and scope

Start: Variable declared

↓

Ownership assigned

↓

Variable used in scope

↓

Scope ends

↓

Ownership dropped, memory freed

↓

End

This flow shows how a variable is created, used within its scope, and then dropped when the scope ends, freeing ownership and memory.

Execution Sample

Rust

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

This code creates a String, owns it in variable s, prints it, then drops s at the end of main.

Execution Table

Step	Action	Variable 's' State	Ownership Status	Memory Status	Output
1	Declare s with String::from("hello")	s = "hello"	s owns the String	Memory allocated for "hello"
2	Print s	s = "hello"	s owns the String	Memory allocated for "hello"	hello
3	End of main scope	s goes out of scope	Ownership dropped	Memory freed

💡 Scope ends, ownership of s is dropped, memory is freed automatically

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3 (End)
s	uninitialized	"hello"	"hello"	dropped (no longer valid)

Key Moments - 3 Insights

Why does the variable s become invalid after the scope ends?

Because ownership of s is tied to its scope, when the scope ends (see execution_table step 3), Rust automatically drops s and frees its memory.

Can we use s after the scope ends?

No, after step 3 in the execution_table, s is dropped and no longer valid, so using it would cause a compile error.

What happens to the memory allocated for s when it goes out of scope?

Rust automatically frees the memory when ownership is dropped at scope end, as shown in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is the ownership status of s at step 2?

A Ownership dropped

B s is borrowed

C s owns the String

D s is uninitialized

💡 Hint

Check the 'Ownership Status' column at step 2 in the execution_table

At which step does the memory allocated for s get freed?

A Step 3

B Step 2

C Step 1

D Memory is never freed

💡 Hint

Look at the 'Memory Status' column in the execution_table

If we tried to print s after step 3, what would happen?

A It would print "hello" again

B Compile error because s is dropped

C It would print an empty string

D Runtime error but compiles fine

💡 Hint

Refer to key_moments about variable validity after scope ends

Concept Snapshot

Ownership means a variable owns its data and is responsible for freeing it.
Scope is where the variable is valid.
When scope ends, ownership is dropped and memory is freed.
You cannot use a variable after its scope ends.
Rust enforces this to prevent memory errors.

Full Transcript

This visual execution shows how Rust manages ownership and scope. First, a variable s is declared and owns a String with value "hello". Then s is used to print the string. Finally, when the main function ends, s goes out of scope, ownership is dropped, and Rust automatically frees the memory. This prevents memory leaks and invalid access. The variable s cannot be used after its scope ends because it no longer owns any data. This is the core of Rust's ownership and scope rules.

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