Lifetimes Quiz - Languages Rust

Free practice quiz: Lifetimes (Languages Rust). 40 multiple-choice questions with answers and explanations. Play online, no sign-up needed.

This Languages Rust practice quiz has 40 multiple-choice questions on Lifetimes, and 40 of them come with an explanation. Try the 5 sample questions below (tap an option to check yourself), then play the full quiz online. No sign-up needed.

Sample questions

1. In Rust, what is the primary purpose of lifetimes?

   1. To ensure that references do not outlive the data they point to.
   2. To manage memory allocation and deallocation automatically.
   3. To enforce type safety at compile time.
   4. To allow for concurrent data access without data races.
   Show answer

   Answer: A. To ensure that references do not outlive the data they point to.

   Lifetimes are a compile-time mechanism in Rust that prevents dangling references. They ensure that a reference is always valid and points to valid data. This is crucial for memory safety.

2. Which of the following is NOT a valid lifetime elision rule in Rust?

   1. If there is exactly one input lifetime parameter, that lifetime is assigned to the return value.
   2. If there are multiple input lifetime parameters, but one of them is `&self` or `&mut self`, the lifetime of `self` is assigned to the return value.
   3. If there are multiple input lifetime parameters and the output lifetime cannot be determined, the output lifetime is always `'static`.
   4. If a reference parameter is a field in a struct, its lifetime is tied to the struct's lifetime.
   Show answer

   Answer: C. If there are multiple input lifetime parameters and the output lifetime cannot be determined, the output lifetime is always `'static`.

   Rust's lifetime elision rules are designed to avoid ambiguity. The third option is incorrect; if the output lifetime cannot be determined from the inputs (especially with multiple inputs without a clear relationship to the output), the compiler will require explicit lifetime annotations, rather than defaulting to `'static` which might be incorrect and unsafe.

3. What does the following code snippet attempt to do, and what lifetime issue might arise?

   1. `let mut vec = vec![1, 2]; let r1 = &vec; let r2 = &vec[0]; vec.push(3);` The issue is that `r1` might become invalid if `vec.push(3)` causes reallocation, invalidating `r2`.
   2. `let mut vec = vec![1, 2]; let r1 = &vec; let r2 = &vec[0]; vec.push(3);` The issue is that `r2` might become invalid if `vec.push(3)` causes reallocation, invalidating `r1`.
   3. `let mut vec = vec![1, 2]; let r1 = &vec; let r2 = &vec[0]; vec.push(3);` No lifetime issue arises as `vec` is mutable.
   4. `let mut vec = vec![1, 2]; let r1 = &vec; let r2 = &vec[0]; vec.push(3);` The issue is a type mismatch between `r1` and `r2`.
   Show answer

   Answer: B. `let mut vec = vec![1, 2]; let r1 = &vec; let r2 = &vec[0]; vec.push(3);` The issue is that `r2` might become invalid if `vec.push(3)` causes reallocation, invalidating `r1`.

   When you `push` into a `Vec` that might need to reallocate its internal buffer, all existing references to elements within that `Vec` (like `r2`) can become invalidated. Although `r1` is a reference to the `Vec` itself, the potential reallocation is the core issue that can break `r2`. Rust's borrow checker will prevent this code from compiling because the mutable borrow via `vec.push(3)` conflicts with the immutable borrow `r1` (and by extension, `r2`), but the underlying concern is the invalidation of `r2` if `push` reallocates.

4. Consider a function that takes a reference to a string slice and returns a reference to a character within that slice. What is the most appropriate lifetime annotation?

   1. `fn get_first_char<'a>(s: &'a str) -> Option<&'a u8>`
   2. `fn get_first_char(s: &str) -> Option<&u8>`
   3. `fn get_first_char<'a>(s: &'a str) -> Option<&'static u8>`
   4. `fn get_first_char<'a>(s: &'a str) -> Option<&'b u8>`
   Show answer

   Answer: A. `fn get_first_char<'a>(s: &'a str) -> Option<&'a u8>`

   The function receives a string slice with lifetime `'a`. It returns a reference to a byte within that string slice. Therefore, the returned reference's lifetime must be tied to the input reference's lifetime `'a`. Using `Option<&'a u8>` correctly expresses this.

5. Can a struct definition itself have lifetime parameters?

   1. Yes, if the struct contains references, it must be parameterized by the lifetimes of those references.
   2. No, lifetimes are only for functions and methods.
   3. Yes, but only if the struct is `#[derive(Clone)]`.
   4. Yes, but only if the struct's fields are primitive types.
   Show answer

   Answer: A. Yes, if the struct contains references, it must be parameterized by the lifetimes of those references.

   Structs that hold references need to declare lifetime parameters to ensure memory safety. These parameters are bound to the lifetimes of the references within the struct, preventing the struct from outliving the data its references point to.

More questions in this quiz

Answers and explanations are in the full quiz.

1. What does the following Rust function signature imply about the lifetime of the returned string slice?
2. What is a 'dangling reference' in Rust, and how do lifetimes help prevent it?
3. What is the primary meaning of the lifetime annotation `'a` in a Rust function signature like `fn foo<'a>(s: &'a str)`?
4. In Rust, what does the `'static` lifetime signify?
5. What is the purpose of the `impl Trait` syntax with respect to lifetimes?
6. In the context of Rust structs holding references, what does it mean if a struct definition like `struct RefHolder<'a> { data: &'a str }` is used?
7. What does the `'a` in `fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str` represent?
8. Consider the Rust code: `struct Node { next: Option<&'a Node> }`. What is the issue with this struct definition?
9. What is the main benefit of Rust's lifetime system compared to manual memory management or garbage collection?
10. In a function `fn process(data: &[&'a str]) -> &'a str`, what is the inferred lifetime of the returned string slice?
11. What happens if a Rust program attempts to use a reference after its lifetime has ended?
12. Consider the lifetime annotation `fn foo<'a>(a: &'a i32, b: &i32) -> &'a i32`. Which input reference's lifetime is applied to the return value?
13. What is the purpose of lifetime annotations on methods within `impl` blocks?
14. In Rust, when is it appropriate to use explicit lifetime annotations for function parameters?
15. If a function returns a reference to a local variable declared within that function, what will happen?
16. What is the purpose of the `'a` in `struct StringSliceContainer<'a>` when used in conjunction with `data: &'a str`?
17. In the context of Rust structs with references, what happens if a struct definition uses a reference without a lifetime parameter, like `struct BadContainer { data: &str }`?
18. Which of the following Rust functions correctly uses lifetime annotations to ensure that the returned reference is valid?
19. What does it mean for a lifetime to be generic in Rust, e.g., `fn foo<'a>(s: &'a str)`?
20. Consider `struct Excerpt<'a> { text: &'a str }`. If we create an `Excerpt` holding a reference to a local variable that goes out of scope, what happens?
21. What does the lifetime annotation on a trait method parameter, like `fn example(&self, other: &Self)`, imply?
22. What is a 'non-lexical lifetime' (NLL) in Rust?
23. Consider `struct Wrapper<'a> { inner: &'a mut String }`. If `wrapper.inner.push_str("hello")` is called, what lifetime constraints are at play?
24. What is the key difference between `&str` and `String` regarding lifetimes?
25. Which of the following scenarios would be correctly prevented by Rust's lifetime system?
26. Consider the lifetime parameter in `fn process_slice<'a>(slice: &'a [i32])`. What is the minimum lifetime required for `slice`?
27. What is the role of lifetime annotations in generic structs like `struct Point<T> { x: T, y: T }` if `T` can be a reference?
28. What does the `&'a mut` syntax represent in Rust?
29. What happens if you try to use a reference `r` after the variable it refers to has been dropped?
30. What is the lifetime annotation `'a` in `fn takes_long_string<'a>(s: &'a str)`?
31. In Rust, lifetimes are primarily concerned with:
32. Consider `struct DataHolder<'a> { data: &'a i32 }`. If `holder1` has lifetime `'a` and `holder2` has lifetime `'b`, and `'a` is shorter than `'b`, which holder is more restrictive in its lifespan?
33. In the signature `fn process_iter<'a, 'b>(iter1: &'a Iterator, iter2: &'b Iterator) -> &'a Iterator`, what is the primary implication of the lifetimes?
34. What is the effect of using `#[derive(Clone)]` on a struct that contains references?
35. Consider `struct Data<'a, 'b> { ref1: &'a i32, ref2: &'b i32 }`. What does this struct definition imply about its lifetime parameters?

More quizzes

• Syntax▶ Play
• Concurrency▶ Play

Browse all Rust quizzes

More to play