Lifetimes in structs in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of struct with lifetime reference

What is the output of this Rust program?

Rust

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

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

A hello

B Compilation error due to missing lifetime

C Runtime error: dangling reference

D hellohello

💡 Hint

Look at how the lifetime 'a is used to tie the reference in the struct to the variable text.

The struct Holder has a lifetime parameter 'a that ensures the reference value lives at least as long as 'a. Since text lives in main and h borrows it, printing h.value outputs "hello" safely.

🧠 Conceptual

intermediate

Why use lifetimes in structs?

Why do we need to specify lifetimes in structs that hold references in Rust?

A To automatically clone the referenced data

B To allow the struct to own the data instead of borrowing

C To tell the compiler how long the references inside the struct are valid

D To enable the struct to be mutable

💡 Hint

Think about what problem lifetimes solve when using references.

Lifetimes in structs tell the compiler how long the references inside the struct are valid, preventing dangling references and ensuring memory safety.

🔧 Debug

advanced

Identify the lifetime error

What error does this Rust code produce?

Rust

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

fn create_container<'a>() -> Container<'a> {
    let s = String::from("data");
    Container { data: &s }
}

A error: borrowed value does not live long enough

B error: missing lifetime specifier in return type

C error: cannot move out of borrowed content

D no error, compiles successfully

💡 Hint

Consider the lifetime of s and the returned Container.

The function returns a Container holding a reference to s, but s is dropped when the function ends, so the reference would be invalid. Rust reports a "borrowed value does not live long enough" error.

📝 Syntax

advanced

Correct lifetime syntax in struct definition

Which option correctly defines a struct with a lifetime parameter for a reference field?

A struct RefHolder { value: &'a str }

B struct RefHolder<'a> { value: &str<'a> }

C struct RefHolder { value: &str }

D struct RefHolder<'a> { value: &'a str }

💡 Hint

Remember where the lifetime parameter goes in the struct definition and field type.

Option D correctly declares the lifetime parameter 'a on the struct and uses it in the reference type. Option D misses the lifetime parameter, B has wrong syntax, and D uses 'a without declaring it.

🚀 Application

expert

Lifetime usage in nested structs

Given these structs, what is the output of the program?

Rust

struct Inner<'a> {
    text: &'a str,
}

struct Outer<'a> {
    inner: Inner<'a>,
}

fn main() {
    let s = String::from("Rust");
    let inner = Inner { text: &s };
    let outer = Outer { inner };
    println!("{}", outer.inner.text);
}

A Empty string printed

B Rust

C Runtime error: use after free

D Compilation error due to missing lifetime in Outer

💡 Hint

Check how lifetimes propagate through nested structs.

Both Inner and Outer structs have lifetime 'a, ensuring the reference to s is valid when printed. The program prints "Rust" safely.