Rust Ownership and Borrowing Quiz

What happens when the following Rust code is executed? fn take_ownership(s: String) { println!("{}", s); } fn main() { let s1 = String::from("Hello"); let s2 = s1; take_ownership(s1); println!("{}", s2); }

• The code compiles and runs, printing "Hello" twice.

• The code fails to compile because s1 is used after being moved.

• The code compiles but panics at runtime due to invalid memory access.

• The code compiles and runs, but only s2 is printed.

Which of the following code snippets correctly demonstrates a valid use of borrowing to avoid ownership issues? fn print_length(s: &String) -> usize { s.len() } fn main() { let s = String::from("Rust"); let len = print_length(&s); println!("String: {}, Length: {}", s, len); }

• The code above is correct and will compile.

• The code will fail to compile because s is moved into print_length.

• The code will compile but cause a runtime error due to dangling references.

• The code will fail to compile because &String requires a mutable reference.

Consider the following code involving lifetimes. What is the outcome? fns longest(s1: &str, s2: &str) -> &str { if s1.len() > s2.len() { s1 } else { s2 } } fn main() { let s1 = String::from("short"); let result; { let s2 = String::from("longer"); result = longest(&s1, &s2); } println!("Longest: {}", result);

• The code compiles and runs, printing "Longest: longer".

• The code fails to compile because s2 does not live long enough.

• The code compiles but panics at runtime due to invalid memory access.

• The code compiles and runs, but result is undefined.

Which of the following code snippets correctly uses a mutable reference while adhering to Rust’s ownership and borrowing rules?

• 
• 
• 
• 

What is the purpose of the Copy and Clone traits in the context of Rust’s ownership model, and which of the following statements is true?

• Types implementing Copy are always moved, and Clone is used for deep copying.

• Types implementing Copy are copied implicitly instead of moved, while Clone allows explicit copying.

• Copy and Clone are interchangeable, but Copy is more efficient for small types.

• Clone is automatically implemented for all types, but Copy requires manual implementation.