Lifetimes in structs in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a lifetime in Rust?

A lifetime in Rust is a way to tell the compiler how long a reference should be valid. It helps prevent dangling references and ensures memory safety.

beginner

Why do structs sometimes need lifetime annotations?

Structs need lifetime annotations when they hold references. This tells Rust how long those references are valid, so the compiler can check safety.

beginner

How do you declare a struct with a lifetime parameter?

You add a lifetime parameter with an apostrophe before the lifetime name, like struct MyStruct<'a> { field: &'a str }. This means the field's reference lives at least as long as 'a.

intermediate

What happens if you omit lifetime annotations on references in structs?

Rust will give a compile error because it can't be sure how long the references live. You must specify lifetimes to avoid dangling references.

intermediate

Explain the difference between &'a T and T in a struct field.

&'a T is a reference with a lifetime 'a, meaning it borrows data that lives at least as long as 'a. T owns the data directly, so no lifetime is needed.

Why do you add a lifetime parameter to a struct in Rust?

A To allow the struct to own data

B To make the struct mutable

C To specify how long references inside the struct are valid

D To enable multithreading

Lifetime parameters tell Rust how long references inside the struct must be valid to ensure safety.

What does the syntax &'a str mean in a struct field?

A A reference to a string slice valid for lifetime 'a

B An owned string with lifetime 'a

C A mutable string reference

D A static string

It means a reference to a string slice that lives at least as long as the lifetime 'a.

What error occurs if you forget to add lifetime annotations to references in structs?

A Compile error about missing lifetime specifier

B Runtime error

C Warning only, code compiles

D No error, Rust infers lifetimes automatically

Rust requires explicit lifetime annotations on references in structs to ensure safety.

Which of these is a correct way to declare a struct with a lifetime?

A struct Example { field: &i32 }

B struct Example<'a> { field: &'a i32 }

C struct Example<'a> { field: i32 }

D struct Example { field: &'a i32 }

You must declare the lifetime parameter 'a on the struct and use it on the reference.

What does the lifetime parameter 'a guarantee?

A The reference is mutable

B The reference is static

C The data is owned by the struct

D The reference lives at least as long as 'a

The lifetime 'a means the reference must be valid for at least the lifetime 'a.

Explain why lifetime annotations are necessary in structs that hold references.

Think about how Rust ensures memory safety with references inside structs.

Describe how to declare a struct with a lifetime parameter and a reference field.

Focus on the syntax for lifetime parameters and reference fields.

Practice

1. What is the main purpose of using lifetimes in Rust structs?

easy

A. To make structs mutable by default

B. To increase the speed of the program

C. To allow structs to own data permanently

D. To tell Rust how long references inside the struct are valid

Solution

1. Step 1: Understand what lifetimes represent

   Lifetimes describe how long references are valid to prevent invalid memory access.

2. Step 2: Connect lifetimes to structs

   In structs, lifetimes tell Rust how long the references inside the struct remain valid.

3. Final Answer:

   To tell Rust how long references inside the struct are valid -> Option D

4. Quick Check:

   Lifetimes = reference validity [OK]

Hint: Lifetimes track reference validity duration in structs [OK]

Common Mistakes:

• Thinking lifetimes control program speed
• Confusing ownership with lifetimes
• Assuming lifetimes make structs mutable

2. Which of the following is the correct syntax to declare a struct with a lifetime parameter named 'a'?

easy

A. struct Example { data: &str<'a> }

B. struct Example<'a> { data: &'a str }

C. struct Example { data: &'a str }

D. struct Example<'a> { data: &str'a }

Solution

1. Step 1: Recall lifetime syntax in structs

   Lifetime parameters are declared after the struct name with angle brackets, e.g., 'a.

2. Step 2: Match correct placement of lifetime

   The lifetime must be declared as 'a after struct name and used before the reference type.

3. Final Answer:

   struct Example<'a> { data: &'a str } -> Option B

4. Quick Check:

   Lifetime syntax = struct Name<'a> { field: &'a Type } [OK]

Hint: Lifetime goes after struct name and before reference type [OK]

Common Mistakes:

• Placing lifetime after &str instead of before
• Omitting lifetime parameter after struct name
• Using incorrect lifetime syntax like &str<'a>

3. What will be the output of this Rust code?

struct Holder<'a> {
    value: &'a i32,
}

fn main() {
    let x = 10;
    let h = Holder { value: &x };
    println!("{}", h.value);
}

medium

A. 10

B. Compilation error due to missing lifetime

C. Runtime error: dangling reference

D. 0

Solution

1. Step 1: Analyze struct and lifetime usage

   The struct Holder has a lifetime 'a for its reference field. The reference &x is valid inside main.

2. Step 2: Check code execution

   Variable x is 10, h.value references x, so printing h.value outputs 10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Reference points to 10, so output = 10 [OK]

Hint: Valid lifetime means reference prints correct value [OK]

Common Mistakes:

• Assuming compilation error without lifetime annotation
• Expecting runtime error for valid reference
• Confusing output with zero or default

4. Identify the error in this Rust code:

struct Container<'a> {
    data: &'a str,
}

fn main() {
    let c;
    {
        let s = String::from("hello");
        c = Container { data: &s };
    }
    println!("{}", c.data);
}

medium

A. Error: 's' does not live long enough for 'c'

B. Error: Missing lifetime parameter in struct

C. Error: Cannot print &str directly

D. No error, code runs fine

Solution

1. Step 1: Understand variable lifetimes

   Variable 's' is created inside inner block and dropped at block end.

2. Step 2: Analyze reference validity

   Container 'c' holds reference to 's', but 's' is dropped before 'c' is used, causing invalid reference.

3. Final Answer:

   Error: 's' does not live long enough for 'c' -> Option A

4. Quick Check:

   Reference lifetime shorter than struct usage = error [OK]

Hint: Check if referenced data outlives struct instance [OK]

Common Mistakes:

• Ignoring inner block scope of 's'
• Thinking missing lifetime parameter causes error here
• Assuming printing &str causes error

5. You want to create a struct that holds two string slices with different lifetimes. Which is the correct way to declare it?

hard

A. struct Pair { first: &str, second: &str }

B. struct Pair<'a> { first: &'a str, second: &'a str }

C. struct Pair<'a, 'b> { first: &'a str, second: &'b str }

D. struct Pair<'a> { first: &'a str, second: &str }

Solution

1. Step 1: Understand multiple lifetimes in structs

   When fields have different lifetimes, declare multiple lifetime parameters.

2. Step 2: Match declaration to fields

   Each field uses its own lifetime parameter, so struct must declare both 'a and 'b.

3. Final Answer:

   struct Pair<'a, 'b> { first: &'a str, second: &'b str } -> Option C

4. Quick Check:

   Different lifetimes need separate parameters [OK]

Hint: Use separate lifetime parameters for different references [OK]

Common Mistakes:

• Using one lifetime for different lifetime references
• Omitting lifetime parameters entirely
• Mixing owned and borrowed types without lifetimes