Quelle est la façon correcte d'utiliser la durée de vie avec un struct dans la Rouille?

Il n'y a effectivement plus d'un raison pour laquelle le code ci-dessus échoue. Nous allons décomposer un peu et explorer quelques options sur la façon de le résoudre.

Laissez-moi d'abord de supprimer la new et essayez de construire une instance de A directement dans main, de sorte que vous voyez que la première partie du problème n'a rien à voir avec la durée de vie:

struct C;

struct B<'b> {
    c: &'b C,
}

struct A<'a> {
    b: B<'a>,
    c: C,
}

fn main() {
    //I copied your new directly here
    //and renamed c1 so we know what "c"
    //the errors refer to
    let c1 = C;

    let _ = A {
        c: c1,
        b: B { c: &c1 },
    };
}

cela échoue avec:

error[E0382]: use of moved value: `c1`
  --> src/main.rs:20:20
   |
19 |         c: c1,
   |            -- value moved here
20 |         b: B { c: &c1 },
   |                    ^^ value used here after move
   |
   = note: move occurs because `c1` has type `C`, which does not implement the `Copy` trait

ce qu'il dit, c'est que si vous affectez c1 à c, vous vous déplacez à sa propriété à c (c'est à dire que vous ne pouvez pas y accéder plus longtemps grâce à c1, uniquement par le biais de c). Cela signifie que toutes les références à c1 ne serait plus valide. Mais vous avez un &c1 toujours dans la portée (B), de sorte que le compilateur ne pouvez pas vous permettre de compiler ce code.

Le compilateur fait allusion à une possible solution dans le message d'erreur quand il dit que le type C est non-copiable. Si vous pouviez faire une copie d'un C, votre code peut alors être valable, car l'attribution de c1 à c serait de créer une nouvelle copie de la valeur au lieu d'aller de propriété de l'original de la copie.

Nous pouvons faire C copiable par l'évolution de sa définition comme ceci:

#[derive(Copy, Clone)]
struct C;

Maintenant le code ci-dessus fonctionne. Notez que ce @matthieu-m commentaires est toujours vrai: nous ne pouvons pas stocker à la fois la référence à une valeur, et la valeur elle-même en B (nous sommes en conservant une référence à une valeur et une COPIE de la valeur ici). Ce n'est pas juste pour les structures, cependant, c'est comment la propriété des œuvres.

Maintenant, si vous ne voulez pas (ou ne peut pas) faire C copiable, vous pouvez stocker des références dans les deux A et B à la place.

struct C;

struct B<'b> {
    c: &'b C,
}

struct A<'a> {
    b: B<'a>,
    c: &'a C, //now this is a reference too
}

fn main() {
    let c1 = C;
    let _ = A {
        c: &c1,
        b: B { c: &c1 },
    };
}

Tous bon alors? Pas vraiment... on a encore envie de se déplacer à la création de A de retour dans une new méthode. Et c'est là QUE nous allons lancer en difficulté avec la durée de vie. Passons à la création de A de retour dans une méthode:

impl<'a> A<'a> {
    fn new() -> A<'a> {
        let c1 = C;
        A {
            c: &c1,
            b: B { c: &c1 },
        }
    }
}

comme prévu, voici notre durée de vie d'erreur:

error[E0597]: `c1` does not live long enough
  --> src/main.rs:17:17
   |
17 |             c: &c1,
   |                 ^^ borrowed value does not live long enough
...
20 |     }
   |     - borrowed value only lives until here
   |
note: borrowed value must be valid for the lifetime 'a as defined on the impl at 13:1...
  --> src/main.rs:13:1
   |
13 | impl<'a> A<'a> {
   | ^^^^^^^^^^^^^^

error[E0597]: `c1` does not live long enough
  --> src/main.rs:18:24
   |
18 |             b: B { c: &c1 },
   |                        ^^ borrowed value does not live long enough
19 |         }
20 |     }
   |     - borrowed value only lives until here
   |
note: borrowed value must be valid for the lifetime 'a as defined on the impl at 13:1...
  --> src/main.rs:13:1
   |
13 | impl<'a> A<'a> {
   | ^^^^^^^^^^^^^^

c'est parce que c1 est détruit à la fin de la new méthode, on ne peut donc pas renvoyer une référence.

fn new() -> A<'a> {
    let c1 = C; //we create c1 here
    A {
        c: &c1,          //...take a reference to it
        b: B { c: &c1 }, //...and another
    }
} //and destroy c1 here (so we can't return A with a reference to c1)

Une solution possible est de créer C à l'extérieur de new et passer comme paramètre:

struct C;

struct B<'b> {
    c: &'b C,
}

struct A<'a> {
    b: B<'a>,
    c: &'a C
}

fn main() {
    let c1 = C;
    let _ = A::new(&c1);
}

impl<'a> A<'a> {
    fn new(c: &'a C) -> A<'a> {
        A {c: c, b: B{c: c}}
    }
}

aire de jeux

OriginalL'auteur Paolo Falabella