Estructuras

La anotación de vidas útiles en estructuras también es similar a funciones:

// Un tipo `Prestado` que contiene una referencia a un `i32`.
// La referencia a `i32` debe sobrevivir a `Prestado`.
#[derive(Debug)]
struct Prestado<'a>(&'a i32);

// Del mismo modo, ambas referencias aquí deben sobrevivir a esta estructura.
#[derive(Debug)]
struct PrestadoNombrado<'a> {
    x: &'a i32,
    y: &'a i32,
}

// Una enumeración que es una `i32` o una referencia a una.
#[derive(Debug)]
enum Cualquiera<'a> {
    Num(i32),
    Ref(&'a i32),
}

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

    let simple = Prestado(&x);
    let doble = PrestadoNombrado { x: &x, y: &y };
    let referencia = Cualquiera::Ref(&x);
    let numero     = Cualquiera::Num(y);

    println!("x es prestado en {:?}", simple);
    println!("x y y son prestados en {:?}", doble);
    println!("x es prestado en {:?}", referencia);
    println!("y *no* es prestado en {:?}", numero);
}

Ve también

structs