Kiedy jest przydatne definiowanie wielu żyć w strukturze?

Question

Kiedy jest przydatne definiowanie wielu żyć w strukturze?

W Rust, gdy chcemy, aby struktura zawierała odwołania, zazwyczaj definiujemy ich życia jako takie:

struct Foo<'a> {
    x: &'a i32,
    y: &'a i32,
}

Ale możliwe jest również zdefiniowanie wielu okresów życia dla różnych odwołań w tej samej strukturze:

struct Foo<'a, 'b> {
    x: &'a i32,
    y: &'b i32,
}

Kiedy jest to przydatne, aby to zrobić? Czy ktoś może podać przykładowy kod, który nie kompiluje się, gdy oba życia są 'a, ale kompiluje, gdy życia są 'a i 'b (lub odwrotnie)?

45

rust lifetime

Author: Kai, 2015-04-25

Source

2 answers

Oto kolejny prosty przykład, w którym definicja struktury musi używać dwóch okresów życia, aby działać zgodnie z oczekiwaniami. Nie dzieli agregatu na pola o różnych okresach życia, ale zagnieżdża strukturę z inną strukturą.

struct X<'a>(&'a i32);

struct Y<'a, 'b>(&'a X<'b>);

fn main() {
    let z = 100;
    //taking the inner field out of a temporary
    let z1 = ((Y(&X(&z))).0).0;  
    assert!(*z1 == z);
}

Struktura Y ma dwa parametry życia, jeden dla jej zawartego pola &X i jeden dla X's zawartego pola &z.

W operacji ((Y(&X(&z))).0).0, X(&z) jest tworzony jako tymczasowy i jest pożyczony. Jego żywotność mieści się tylko w zakresie tej operacji, wygasa na końcu instrukcji. Ponieważ jednak czas życia X(&z) różni się od pola its &z, operacja może zwrócić &z, do którego wartości można uzyskać dostęp później w funkcji.

Jeśli używasz pojedynczego życia dla Y struktury. Ta operacja nie będzie działać, ponieważ żywotność &z jest taka sama jak jej zawierająca struktura X(&z), wygasa na końcu instrukcji; dlatego zwrócona &z nie jest już ważna, aby być dostępna później.

Zobacz kod w .

8

Author: Xiao-Feng Li,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-09-19 21:29:25

score 24 · Accepted Answer

Po zbyt późnym wstawaniu, udało mi się wymyślić przykładowy przypadek, w którym życie ma znaczenie. Oto kod:

static ZERO: i32 = 0;

struct Foo<'a, 'b> {
    x: &'a i32,
    y: &'b i32,
}

fn get_x_or_zero_ref<'a, 'b>(x: &'a i32, y: &'b i32) -> &'a i32 {
    if *x > *y {
        return x
    } else {
        return &ZERO
    }
}

fn main() {
    let x = 1;
    let v;
    {
        let y = 2;
        let f = Foo { x: &x, y: &y };
        v = get_x_or_zero_ref(&f.x, &f.y);
    }
    println!("{}", *v);
}

Gdyby zmienić definicję Foo na taką:

struct Foo<'a> {
    x: &'a i32,
    y: &'a i32,
}

Wtedy kod nie będzie kompilowany.

Zasadniczo, jeśli chcesz użyć pól struktury w dowolnej funkcji, która wymaga, aby jej parametry miały różne okresy życia, to pola struktury muszą mieć również inne okresy życia.