Login Register

What Are Lifetimes in Rust?

by
Previous
Next

When you make a reference in Rust (like &x), that reference can only be used as long as the original data (x) still exists.

The time period from when the reference is created until the moment it’s no longer safe to use (because the data might be gone) is called the lifetime of the reference.

Real-Life Analogy:

If you borrow your friend’s book, you can only read it while your friend still owns the book. The time you are allowed to keep reading is the lifetime of your borrow. Once your friend takes the book back (data destroyed), your borrow (reference) is no longer valid.

Why Do We Need Lifetimes?

If you create a reference (like &x), it should never point to garbage or destroyed data.

1) Dangling References: A dangling reference happens when you try to use a reference after the original data is gone. Rust uses lifetimes to stop this problem.

For example: 

fn main() {
    let r; 
    {
        let x = 10;
        r = &x;   // r borrows x
    } // x is dropped here, memory is gone

    // println!("{}", r); // ERROR: r points to destroyed data
}
  • Rust will not allow this. Without lifetimes, this could become dangerous.

2) Memory Corruption: If you use references to invalid or out-of-scope data, your program might read/write garbage memory. Rust prevents this by enforcing lifetimes.

3) Confusion Over Ownership: Sometimes it’s not clear: Who owns the data, and who just borrows it? Lifetimes make it clear how long a reference is allowed to live compared to the data.

For example:

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

Example of a Dangling Reference (Compile-Time Error)

fn main() {
    let r;  
    {
        let x = 5;
        r = &x; // r is borrowing x
    } // x is destroyed here
    // println!("{}", r); // r is now invalid
}
  • We create a variable r that will later hold a reference.
  • Inside the block { . . . }, we make a variable x = 5.
  • Then r = &x; → Here r borrows x.
  • So now r points to the memory location where x lives.
  • When the block ends ( } ), variable x is dropped (destroyed). The memory where x lived is freed.
  • But r is still there! If you try to use r, it would point to memory that no longer exists.

Where this method works in real-life projects?

We can use this methods in multiple programs, such as:

  • Web Servers (handling requests and responses)
  • Databases
  • Command-line Tools
  • Embedded Systems

For example, Imagine you build a web server in Rust.

  • A client sends a request (string data).
  • You parse only part of that string (like the URL or query).
  • Instead of copying the whole string, you just pass a slice reference.
  • Lifetimes ensure that the reference to the request data doesn’t outlive the request itself.
  • If the request is gone, your slice cannot exist , compiler catches this.

Basic Syntax of Lifetimes

A lifetime is written with an apostrophe ‘ and a name, like ‘a. It’s just a label that marks the time a reference can be safely used.

We write these labels in function definitions or structs to explain: “This reference cannot live longer than that reference.”

Syntax Example

fn example<'a>(input: &'a str) -> &'a str {
    input
}

Here:

  • ‘a is a lifetime parameter.
  • It indicates that the input reference and the returned reference have the same lifetime.

How Rust Handles Lifetimes

In many simple cases, the compiler figures out lifetimes automatically. This is called lifetime elision (which means Rust “hides” the lifetime labels for you).

But in more complex cases, Rust cannot guess. Then you must write the lifetime explicitly (using ‘a, ‘b, etc.) to show how long references are valid and how they relate to each other.

Example of Automatic Lifetime Elision

fn first_char(text: &str) -> &str {
    &text[0..1]  // Rust automatically knows input and output share same lifetime
}

fn main() {
    let word = String::from("Rustacean");
    let first = first_char(&word);
    println!("First letter: {}", first);
}
  • Here, Rust automatically assigns lifetimes. We didn’t need to write ‘a.

Example Requiring Explicit Lifetimes

fn choose_longer<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() >= s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let city1 = String::from("Goa");
    let city2 = String::from("Ahmedabad");

    let bigger = choose_longer(&city1, &city2);
    println!("Longer city name: {}", bigger);
}
  • Here, we had to explicitly write ‘a because Rust cannot automatically guess which string (s1 or s2) will be returned.

Lifetimes in Structs

Normally, a struct can own its data (like String, i32, etc.). But sometimes, you don’t want the struct to own data; you just want it to hold references to data stored somewhere else.

Example: Struct with Lifetime

struct Book<'a> {
    title: &'a str,   // reference to a string, valid as long as 'a
    author: &'a str,  // reference to another string, also valid as long as 'a
}

fn main() {
    let title = String::from("Rust Programming");
    let author = String::from("John Doe");

    let book = Book {
        title: &title,   // borrow title
        author: &author, // borrow author
    };

    println!("Book: {}, Author: {}", book.title, book.author);
}
  • Here, the struct Book<‘a> says: I need references that are valid for the lifetime ‘a.
  • The book holds references to the title and author.
  • As long as the title and author are alive, the book is valid.
  • If the title or author goes out of scope, the book cannot exist anymore.

Lifetime Annotations in Functions

Example: Function with Lifetime Annotations

fn pick_first<'a>(x: &'a str, y: &'a str) -> &'a str {
    // Just return the first input reference
    x
}

fn main() {
    let city1 = String::from("Delhi");
    let city2 = String::from("Mumbai");

    let chosen = pick_first(&city1, &city2);
    println!("The chosen city is: {}", chosen);
}

Static Lifetime In Rust

‘static is a special lifetime in Rust. It means the data is available for the entire program run (from start to end). Such data is never freed while the program is running.

Example: Static Lifetime

fn main() {
    let s: &'static str = "This is a static string";
    println!("{}", s);
}
  • ‘static means the data is stored in the program’s binary and never deallocated.

Advanced Concepts: Lifetime Constraints

Lifetime constraints are rules in Rust that define how long references must remain valid in relation to each other, ensuring that returned references cannot outlive the shortest-lived input.

Example: Lifetime Constraints

fn longer_word<'a>(w1: &'a str, w2: &'a str) -> &'a str {
    if w1.len() >= w2.len() {
        w1
    } else {
        w2
    }
}

fn main() {
    let name1 = String::from("Rust");
    let result;
    {
        let name2 = String::from("Programming");
        result = longer_word(&name1, &name2);
        println!("Inside block: {}", result);
    }
    // println!("Outside block: {}", result); // Won’t compile
}

Learn Other Topics About Rust Programming

Previous
Next