Ownership and scope in Rust

Introduction

Ownership and scope help Rust keep track of who can use data and when it should be cleaned up. This avoids bugs and keeps programs safe.

When you want to make sure data is used only where it should be.

When you want Rust to automatically free memory when data is no longer needed.

When you want to avoid mistakes like using data after it is deleted.

When you want to pass data between parts of your program safely.

When you want to understand why some variables can't be used after moving them.

Syntax

Rust

let variable = value; // variable owns the value
// When variable goes out of scope, value is dropped

Every value in Rust has one owner at a time.

When the owner goes out of scope, Rust automatically cleans up the value.

Examples

The string is created and owned by s. When s ends, Rust frees the string.

Rust

fn main() {
    let s = String::from("hello"); // s owns the string
    // s is valid here
} // s goes out of scope here, string is dropped

Ownership moves from s1 to s2. Using s1 after this would cause an error.

Rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // ownership moves to s2
    // s1 can no longer be used
    println!("{}", s2);
}

Simple types like numbers are copied, so both x and y can be used.

Rust

fn main() {
    let x = 5; // x owns the value 5
    let y = x; // copy happens because i32 is simple
    println!("{} {}", x, y); // both can be used
}

Sample Program

This program shows ownership moving from s in main to the print_string function. After moving, s cannot be used in main.

Rust

fn main() {
    let s = String::from("hello");
    print_string(s);
    // println!("{}", s); // This would cause an error because s was moved
}

fn print_string(s: String) {
    println!("Received string: {}", s);
}

Important Notes

When ownership moves, the old owner can no longer use the value.

Scope is the area where a variable is valid. When it ends, Rust cleans up the value.

Copy types like numbers don't move ownership; they are copied instead.

Summary

Ownership means one variable owns a value at a time.

Scope is where a variable is valid and controls when Rust cleans up data.

Moving ownership prevents bugs by making sure only one owner exists.

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