Lifetime annotations in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a lifetime annotation in Rust?

A lifetime annotation tells Rust how long a reference should be valid. It helps the compiler check that references do not outlive the data they point to.

beginner

Why do we need lifetime annotations in Rust?

We need lifetime annotations to avoid dangling references and ensure memory safety by making sure references do not live longer than the data they refer to.

intermediate

Explain the syntax of a lifetime annotation with an example.

A lifetime annotation uses an apostrophe followed by a name, like 'a. For example, fn example<'a>(x: &'a str) -> &'a str means the returned reference lives at least as long as x.

intermediate

What does the following function signature mean?<br>

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str

It means both input string references x and y must live at least as long as lifetime 'a, and the returned reference will also live at least as long as 'a. This ensures the returned reference is valid as long as both inputs.

intermediate

Can Rust always infer lifetimes without annotations?

Rust can infer lifetimes in simple cases using lifetime elision rules. But for complex cases, explicit lifetime annotations are needed to clarify how references relate.

What does a lifetime annotation in Rust specify?

A How long a reference is valid

B The size of a variable

C The type of a variable

D The value of a variable

Lifetime annotations tell Rust how long references should be valid to ensure safety.

Which symbol starts a lifetime annotation in Rust?

A $

B &

C #

D '

Lifetime annotations start with an apostrophe, like 'a.

In the function signature fn foo<'a>(x: &'a i32) -> &'a i32, what does 'a represent?

A A type parameter

B A lifetime parameter

C A variable name

D A constant value

The 'a is a lifetime parameter specifying how long the reference lives.

Why might Rust require explicit lifetime annotations?

A To clarify complex reference relationships

B To improve performance

C To reduce code size

D To allow unsafe code

Explicit lifetimes clarify how references relate when inference is not enough.

What happens if a reference outlives the data it points to in Rust?

A The reference becomes null

B The program crashes immediately

C Rust compiler gives an error

D Rust ignores it

Rust prevents dangling references by giving compile-time errors if lifetimes are violated.

Explain in your own words what lifetime annotations are and why they are important in Rust.

Think about how Rust keeps track of how long references are valid.

Describe the syntax of lifetime annotations and give a simple example function signature using them.

Look at how <code>&#39;a</code> is used in function parameters and return types.