Lifetimes in structs in Rust - Step-by-Step Execution

Concept Flow - Lifetimes in structs

Define struct with lifetime

↓

Create instance with reference

↓

Use instance safely

↓

Lifetime ends when references drop

↓

Memory is safe, no dangling refs

This flow shows how a struct with a lifetime parameter holds references safely until they go out of scope.

Execution Sample

Rust

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

fn main() {
    let text = String::from("hello");
    let h = Holder { value: &text };
    println!("{}", h.value);
}

This code defines a struct with a lifetime, creates an instance holding a reference, and prints the referenced string.

Execution Table

Step	Action	Variable States	Lifetime Check	Output
1	Define struct Holder with lifetime 'a	Holder<'a> defined	No references yet
2	Create String text = "hello"	text = "hello"	text owns data
3	Create Holder h with value = &text	h.value points to text	h.value lifetime <= text lifetime
4	Print h.value	h.value = "hello"	Reference valid	hello
5	End of main, text and h go out of scope	text and h dropped	References cleaned safely

💡 Execution ends as main function scope ends, all references are valid and dropped safely.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
text	uninitialized	"hello"	"hello"	"hello"	dropped
h.value	uninitialized	uninitialized	&text ("hello")	&text ("hello")	dropped

Key Moments - 3 Insights

Why do we need to specify a lifetime 'a in the struct definition?

Because the struct holds a reference, Rust needs to know how long that reference is valid to prevent dangling pointers. See execution_table step 3 where h.value points to text.

What happens if the referenced data (text) goes out of scope before the struct instance?

Rust will give a compile-time error because the struct's reference would be invalid. In the execution_table, step 5 shows both text and h go out of scope safely.

Can the struct hold a reference without a lifetime annotation?

No, Rust requires explicit lifetime annotations on structs holding references to ensure safety, as shown in step 1.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does h.value point to?

A The String text containing "hello"

B An uninitialized variable

C A copy of the string "hello"

D A dangling pointer

💡 Hint

Check the Variable States column at step 3 in execution_table.

At which step does Rust ensure the reference lifetime is valid?

A Step 1

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the Lifetime Check column in execution_table.

If text was dropped before h, what would happen?

A Program runs normally

B Compile-time error due to invalid reference

C Runtime panic

D h.value becomes a copy of text

💡 Hint

Refer to key_moments about lifetime safety and execution_table step 5.

Concept Snapshot

struct Holder<'a> { value: &'a str }  
- 'a is a lifetime parameter
- Ensures reference inside struct lives long enough
- Rust checks lifetimes at compile time
- Prevents dangling references
- Use when struct holds references

Full Transcript

This example shows how Rust uses lifetimes in structs to keep references safe. We define a struct Holder with a lifetime 'a to hold a reference to a string slice. We create a String variable text and then create an instance h of Holder that holds a reference to text. Rust ensures that h's reference does not outlive text. When we print h.value, it safely shows "hello". At the end of main, both text and h go out of scope, and Rust cleans up safely without any dangling references. Lifetimes prevent errors by making sure references inside structs are valid as long as needed but no longer.