Rust `数组`不'；我活得不够长

我想保留一个

挂起的

实例，但我不能，因为它在一个数组中。如何从数组中“提取”此实例并将其保存在

对象中

实例中？（在我的原始代码中，我没有数组，只有迭代器）。以下是等效代码：

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
}

struct保持{
值：u8，
}
结构持有人；
impl支架{
发布fn获取（&self）->[Holded；2]{
[保留的{value:0}，保留的{value:1}]
}
}
结构对象选项{
让mut obj:Object；
让数组=holder.get（）；
对于数组中的h.into_iter（）{
如果h.value==1u8{
obj=对象{holded:h}；
返回一些（obj）；
}
}
没有一个
}

错误消息：

错误：`array`的寿命不够长
-->src/main.rs:28:14
|
28 |对于阵列中的h.intoiter（）{
|^^^^^^^活得不够长
...
36 | }
|-借来的价值仅在此处有效
|
注意：借用值必须在24:43在块上定义的匿名生存期#1内有效。。。
-->src/main.rs:24:44
|
24 | fn工作（支架：&支架）->选项{
|                                            ^

在您发布的MCVE中，struct

对象

包含对持有的

的引用

：

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

您从一个按值返回的函数中获取

Holded

：

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

现在，这将永远不起作用。如果返回对

Holded

的引用，则引用的

Holded

必须存储在某个位置。这意味着要么作为输入，要么作为函数

work（）

的输出

我重写了您的示例，将

Holder

包含在

Holder

中。这是解决此问题的一种方法。但我不确定这是否适用于您原来的问题

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()
}

struct保持{
值：u8，
}
结构持有者{
值：[保留；2]，
}
impl支架{
pub fn new（）->支架{
持有者{value:[持有的{value:0}，持有的{value:1}]}
}
发布fn获取（&self）->&[Holded；2]{
&自我价值
}
}
结构对象选项{
让obj：对象；
让数组=holder.get（）；
对于数组中的h.into_iter（）{
如果h.value==1u8{
obj=对象{holded:h}；
返回一些（obj）；
}
}
没有一个
}
fn工件2（保持架：&保持架）->选项{
holder.get（）
.国际热核实验堆（iter）
.filter（| h | h.value==1u8）
.map（|h |对象{holded:h}）
.next（）
}

---

您注意到我还添加了一种不同的方法来实现

work（）

函数（

work2（）

）.

有。也许你可以花点时间回顾一下其中的一些帖子，解释一下为什么这个问题特别、不同，而且还没有得到回答？我已经看过很多，但这里的问题主要是我不明白我为什么会有这个错误，看到另一篇帖子对我没有帮助。我也见过很多帖子，一个d这个问题用一个问题来解释。-看看当你不指出任何现有问题的错误时它有多有用？如果你不告诉我们错误的地方，我们只会重复你已经不理解的相同答案，你不会得到帮助，更糟糕的是，还有一个答案下一个人不会读，而是会读忽略并要求修复他们的代码。我编译了您的代码，并将整个错误信息放入了问题中。您是否阅读了编译器所说的内容？您是否尝试过？此外，我强烈建议您学习创建一个。这样做将有助于您作为一名程序员的学习和成长。这也非常有帮助，因为您可以只关注问题我在手边，不会被任何多余的垃圾分散注意力。这是。这可能是一个复制品。

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()
}