Lifetime Management in Rust Structs

Introduction

In this lab, we have some Rust code that demonstrates the usage of lifetimes in structs. The code includes a struct called Borrowed that holds a reference to an i32, and the reference must outlive the struct itself. There is also a struct called NamedBorrowed with two references to i32, both of which must outlive the struct. Additionally, there is an enum called Either that can either be an i32 or a reference to one, and the reference must outlive the enum. Finally, the code creates instances of these structs and enum, and prints their contents to showcase the usage of lifetimes in Rust.

Note: If the lab does not specify a file name, you can use any file name you want. For example, you can use main.rs, compile and run it with rustc main.rs && ./main.

Structs

Annotation of lifetimes in structures are also similar to functions:

// A type `Borrowed` which houses a reference to an
// `i32`. The reference to `i32` must outlive `Borrowed`.
#[derive(Debug)]
struct Borrowed<'a>(&'a i32);

// Similarly, both references here must outlive this structure.
#[derive(Debug)]
struct NamedBorrowed<'a> {
    x: &'a i32,
    y: &'a i32,
}

// An enum which is either an `i32` or a reference to one.
#[derive(Debug)]
enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

fn main() {
    let x = 18;
    let y = 15;

    let single = Borrowed(&x);
    let double = NamedBorrowed { x: &x, y: &y };
    let reference = Either::Ref(&x);
    let number    = Either::Num(y);

    println!("x is borrowed in {:?}", single);
    println!("x and y are borrowed in {:?}", double);
    println!("x is borrowed in {:?}", reference);
    println!("y is *not* borrowed in {:?}", number);
}

Summary

Congratulations! You have completed the Structs lab. You can practice more labs in LabEx to improve your skills.