Ownership and scope in Rust - Time & Space Complexity

Time Complexity: Ownership and scope

O(n)

Understanding Time Complexity

We want to see how the time cost changes when using ownership and scope in Rust.

How does the program's work grow as variables move in and out of scope?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn main() {
    let s = String::from("hello");
    {
        let t = s.clone();
        println!("{}", t);
    } // t goes out of scope here
    println!("{}", s);
}
    

This code creates a string, clones it inside a smaller scope, prints both, and shows how ownership and scope work.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Cloning the string inside the inner scope.
• How many times: Once in this example, but cloning cost depends on string length.

How Execution Grows With Input

Cloning a string copies all its characters, so the work grows with string size.

Input Size (string length)	Approx. Operations
10	About 10 copy steps
100	About 100 copy steps
1000	About 1000 copy steps

Pattern observation: The time grows directly with the string length because cloning copies each character.

Final Time Complexity

Time Complexity: O(n)

This means the time to clone grows in a straight line with the size of the string.

Common Mistake

[X] Wrong: "Cloning a string is always a quick, constant-time operation."

[OK] Correct: Cloning copies every character, so it takes longer for bigger strings.

Interview Connect

Understanding how ownership and scope affect time helps you write clear and efficient Rust code, a skill valued in real projects.

Self-Check

"What if we passed the string by reference instead of cloning? How would the time complexity change?"

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