`Array` lebt nicht lange genug

Question

Ich möchte eine Holded Instanz behalten, aber ich kann nicht, da es in einem Array ist. Wie kann ich diese Instanz aus dem Array "extrahieren" und in einer Object Instanz speichern? (In meinem ursprünglichen Code habe ich kein Array, sondern Iteratoren). Hier ist der entsprechende Code:

struct Holded { 
    value: u8, 
} 

struct Holder; 

impl Holder { 
    pub fn get(&self) -> [Holded; 2] { 
     [Holded { value: 0 }, Holded { value: 1 }] 
    } 
} 

struct Object<'a> { 
    holded: &'a Holded, 
} 

fn main() { 
    let holder = Holder; 

    let obj = work(&holder).unwrap(); 
    println!("{}", obj.holded.value); 
} 

fn work(holder: &Holder) -> Option<Object> { 
    let mut obj: Object; 
    let array = holder.get(); 

    for h in array.into_iter() { 
     if h.value == 1u8 { 
      obj = Object { holded: h }; 
      return Some(obj); 
     } 
    } 

    None 
} 

Die Fehlermeldung:

error: `array` does not live long enough 
    --> src/main.rs:28:14 
    | 
28 |  for h in array.into_iter() { 
    |    ^^^^^ does not live long enough 
... 
36 | } 
    | - borrowed value only lives until here 
    | 
note: borrowed value must be valid for the anonymous lifetime #1 defined on the block at 24:43... 
    --> src/main.rs:24:44 
    | 
24 | fn work(holder: &Holder) -> Option<Object> { 
    |           ^

Answer 1

Im MCVE Sie gebucht haben, die Struktur Object enthält einen Verweis auf Holded:

struct Object<'a> { 
    holded: &'a Holded, 
} 

In der Funktion work() geben Sie eine Object (optional) zurück:

fn work(holder: &Holder) -> Option<Object> { 

Sie erwerben Holded aus einer Funktion, die es von Wert zurückgibt:

impl Holder { 
    pub fn get(&self) -> [Holded; 2] { 
     [Holded { value: 0 }, Holded { value: 1 }] 
    } 
} 

Jetzt wird dies nicht funktionieren. Wenn Sie einen Verweis auf Holded zurückgeben, muss die Holded, auf die Sie verweisen, irgendwo gespeichert werden. Dies bedeutet entweder als Eingang oder als Ausgang der Funktion work().

Ich schrieb Ihr Beispiel um Holded innerhalb Holder. Das ist eine Möglichkeit, dies zu lösen. Aber ich bin mir nicht sicher, dass dies für Ihr ursprüngliches Problem gelten würde.

struct Holded { 
    value: u8, 
} 

struct Holder{ 
    value: [Holded; 2], 
} 

impl Holder { 
    pub fn new() -> Holder { 
     Holder {value: [Holded { value: 0 }, Holded { value: 1 }] } 
    } 

    pub fn get(&self) -> &[Holded; 2] { 
     &self.value 
    } 
} 

struct Object<'a> { 
    holded: &'a Holded, 
} 

fn main() { 
    let holder = Holder::new(); 

    let obj = work(&holder).unwrap(); 
    println!("{}", obj.holded.value); 

    let obj = work2(&holder).unwrap(); 
    println!("{}", obj.holded.value); 
} 

fn work(holder: &Holder) -> Option<Object> { 
    let obj: Object; 
    let array = holder.get(); 

    for h in array.into_iter() { 
     if h.value == 1u8 { 
      obj = Object { holded: h }; 
      return Some(obj); 
     } 
    } 

    None 
} 

fn work2(holder: &Holder) -> Option<Object> { 
    holder.get() 
     .iter() 
     .filter(|h| h.value == 1u8) 
     .map(|h| Object { holded: h }) 
     .next() 
} 

Man merkt, ich auch einen anderen Weg, um die work() Funktion (work2()) zu implementieren, hinzugefügt.