11.3 Lifetimes in Rust

Lifetimes are Rust’s tool for ensuring that references always remain valid. They prevent dangling pointers by enforcing that every reference must outlive the scope of its usage. In C, you must manually ensure pointer validity. In Rust, the compiler does much of this work for you at compile time.

11.3.1 Lifetime Annotations

Lifetime annotations (like 'a) label how long references are valid. They affect only compile-time checks and do not generate extra runtime overhead:

fn print_ref<'a>(x: &'a i32) {
    println!("x = {}", x);
}

Here, 'a is a named lifetime for the reference x. Often, Rust can infer lifetimes without annotations.

11.3.2 Lifetimes in Functions

When returning a reference, you usually need to specify how long that reference remains valid relative to any input references:

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

This code won’t compile without lifetime annotations because the compiler cannot infer the return lifetime. With explicit annotations:

#![allow(unused)]
fn main() {
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
}

The lifetime 'a ensures that the returned reference does not outlive x or y.

11.3.3 Lifetime Elision Rules

Rust will infer lifetimes for simple function signatures using these rules:

  1. Each reference parameter gets its own lifetime parameter.
  2. If there’s exactly one input lifetime, the function’s output references use that lifetime.
  3. If multiple input lifetimes exist and one is &self or &mut self, that lifetime is assigned to the output.

Thus, many functions do not need explicit annotations.

11.3.4 Lifetimes in Structs

When a struct includes references, you must declare a lifetime parameter:

struct Excerpt<'a> {
    part: &'a str,
}

fn main() {
    let text = String::from("The quick brown fox jumps over the lazy dog.");
    let first_word = text.split_whitespace().next().unwrap();
    let excerpt = Excerpt { part: first_word };
    println!("Excerpt: {}", excerpt.part);
}

'a links the struct’s reference to the lifetime of text, so it can’t outlive the original string.

11.3.5 Lifetimes with Generics and Traits

You can combine lifetime and type parameters in a single function or trait. For example:

#![allow(unused)]
fn main() {
use std::fmt::Display;

fn announce_and_return_part<'a, T>(announcement: T, text: &'a str) -> &'a str
where
    T: Display,
{
    println!("Announcement: {}", announcement);
    &text[0..5]
}
}

When declaring both lifetime and type parameters, list lifetime parameters first:

fn example<'a, T>(x: &'a T) -> &'a T {
    // ...
}

11.3.6 The 'static Lifetime

A 'static lifetime indicates that data is valid for the program’s entire duration. String literals are 'static by default:

let s: &'static str = "Valid for the entire program runtime";

Use 'static cautiously to avoid memory that never gets deallocated if it’s not genuinely intended to live forever.

11.3.7 Lifetimes and Machine Code

Lifetime checks happen only at compile time. No extra instructions or data structures appear in the compiled binary, so lifetimes are a cost-free safety mechanism.