Why ownership is needed in Rust - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a variable that owns a string.

Rust

let s = String::[1]("hello");

Drag options to blanks, or click blank then click option'

Ato_string

Bfrom

Cnew

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using new which creates an empty String.

Using clone which copies an existing String.

The String::from function creates a new String that owns its data.

2fill in blank

medium

Complete the code to transfer ownership of a String to a function.

Rust

fn takes_ownership(s: String) {
    println!("{}", s);
}

let s1 = String::from("hello");
takes_ownership([1]);

Drag options to blanks, or click blank then click option'

As1

Bref s1

Cs1.clone()

D&s1

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a reference instead of ownership.

Trying to use ref keyword incorrectly.

Passing s1 moves ownership to the function, which is what the function expects.

3fill in blank

hard

Fix the error in the code by choosing the correct way to return ownership.

Rust

fn gives_ownership() -> String {
    let s = String::from("hello");
    [1]
}

let s1 = gives_ownership();

Drag options to blanks, or click blank then click option'

A&s

Breturn &s;

Creturn s;

Ds

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a reference instead of the owned String.

Omitting the return keyword but trying to return a reference.

Using return s; explicitly returns ownership of the String.

4fill in blank

hard

Fill both blanks to create a function that takes ownership and returns it back.

Rust

fn take_and_give_back([1]: String) -> [2] {
    [1]
}

Drag options to blanks, or click blank then click option'

As

BString

C&str

Di32

Attempts:

3 left

💡 Hint

Common Mistakes

Using a reference type &str instead of String.

Using a wrong parameter name.

The function takes ownership of a String named s and returns it back as a String.

5fill in blank

hard

Fill all three blanks to create a function that borrows a String without taking ownership.

Rust

fn calculate_length([1]: [2]) -> [3] {
    [1].len()
}

Drag options to blanks, or click blank then click option'

As

B&String

Cusize

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using owned String instead of a reference.

Returning the wrong type.

The function borrows a String reference &String named s and returns its length as usize.

Practice

1. Why does Rust use ownership rules for managing memory?

easy

A. To make the code run slower

B. To allow multiple owners for the same data

C. To prevent bugs like using data after it is freed

D. To avoid writing any functions

Solution

1. Step 1: Understand ownership purpose

   Ownership ensures each value has a single owner responsible for its memory.

2. Step 2: Identify why ownership is needed

   This prevents bugs like using data after it is freed, which can cause crashes or security issues.

3. Final Answer:

   To prevent bugs like using data after it is freed -> Option C

4. Quick Check:

   Ownership prevents use-after-free bugs = B [OK]

Hint: Ownership prevents memory bugs by single ownership [OK]

Common Mistakes:

• Thinking ownership slows code down
• Believing multiple owners are allowed
• Confusing ownership with function writing

2. Which of the following is the correct way to declare ownership of a String in Rust?

easy

A. let s = &mut "hello";

B. let s: &str = "hello";

C. let s = &String::from("hello");

D. let s = String::from("hello");

Solution

1. Step 1: Identify ownership declaration

   Using let s = String::from("hello"); creates a String with ownership.

2. Step 2: Check other options

   let s: &str = "hello"; is a string slice, not owned String. let s = &String::from("hello"); is a reference, not ownership. let s = &mut "hello"; is invalid syntax.

3. Final Answer:

   let s = String::from("hello"); -> Option D

4. Quick Check:

   String::from creates owned String = A [OK]

Hint: Use String::from to create owned String [OK]

Common Mistakes:

• Confusing &str with owned String
• Using references instead of ownership
• Incorrect mutable reference syntax

3. What will happen when this Rust code runs?

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);

medium

A. Compilation error due to use of moved value

B. Prints 'hello' twice

C. Prints 'hello' once, then error at runtime

D. Prints nothing

Solution

1. Step 1: Understand move semantics

   Assigning s2 = s1 moves ownership from s1 to s2. s1 is no longer valid.

2. Step 2: Check usage of moved value

   Using s1 after move in println! causes compile-time error.

3. Final Answer:

   Compilation error due to use of moved value -> Option A

4. Quick Check:

   Using moved value causes compile error = A [OK]

Hint: Ownership moves on assignment; old owner invalid [OK]

Common Mistakes:

• Expecting both variables to own data
• Thinking code runs but errors at runtime
• Confusing move with copy

4. Find the error in this Rust code related to ownership:

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

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

medium

A. Cannot use s after it was moved to takes_ownership

B. Function takes_ownership should return String

C. String::from is incorrect syntax

D. println! macro is used incorrectly

Solution

1. Step 1: Analyze ownership transfer

   Passing s to takes_ownership moves ownership to the function parameter.

2. Step 2: Identify use after move

   Using s in println! after move causes compile error.

3. Final Answer:

   Cannot use s after it was moved to takes_ownership -> Option A

4. Quick Check:

   Use after move causes error = D [OK]

Hint: Ownership moves into function, original variable invalid after [OK]

Common Mistakes:

• Thinking function must return ownership
• Believing String::from syntax is wrong
• Assuming println! usage is incorrect

5. You want to let a function use a String temporarily without taking ownership. Which Rust feature helps achieve this safely?

hard

A. Using global variables

B. Borrowing with references (&String)

C. Cloning the String inside the function

D. Passing the String by value

Solution

1. Step 1: Understand temporary use without ownership

   Borrowing allows a function to use data without taking ownership by passing a reference.

2. Step 2: Identify correct Rust feature

   Using &String passes a reference, so ownership stays with caller.

3. Final Answer:

   Borrowing with references (&String) -> Option B

4. Quick Check:

   Borrowing uses references to avoid ownership transfer = C [OK]

Hint: Use & to borrow without ownership transfer [OK]

Common Mistakes:

• Thinking cloning is always needed
• Using global variables for ownership
• Passing by value transfers ownership