Reference 借来的价值在循环中的寿命不够长

我试图解析一个文件并从函数返回

Vec

。但是我在文件读取循环中得到了借来的值错误，同时推到了向量

use std::io::{self, BufReader, prelude::*};
use std::fs::File;

fn read() -> Vec<Vec<&'static str>> {
 let file = File::open("~/test").expect("failed to read file");
 let reader = BufReader::new(file);
 let mut main_vector: Vec<Vec<&str>> = Vec::new();
    for line in reader.lines() {
        match line {
            Ok(v) => {
                let mut sub_vector: Vec<&str> = Vec::new();
                for element in v.split_whitespace().collect::<Vec<&str>>() {
                    sub_vector.push(element);
                }
                main_vector.push(sub_vector);
            },
            Err(e) => panic!("failed to parse: {:?}", e),
        }
    }
    //return main_vector;
}

使用std:：io:{self，BufReader，prelude:：*}；
使用std:：fs:：File；
fn read（）->Vec src/main.rs:67:32
|
67 |对于v.split_whitespace（）中的元素。collect:：（）{
|^借来的价值不够长久
...
70 |主|矢量。推力（次|矢量）；
|------借用后在此处使用
71 |             },
|-`v`在这里还借着的时候掉了下来

---

我认为这是关于引用和借用，但我仍然很难弄清楚这一点。

如果提供更多的代码会更好，但我尝试复制它，并得出了以下工作片段：

type Error = i32;

struct Reader
{
    lines: Vec<Result<String, Error>>
}

impl Reader
{
    pub fn new() -> Self
    {
        Self{lines: vec![Ok("foo".into()), Ok("bar".into())]}
    }

    pub fn lines(&self) -> &[Result<String, Error>]
    {
        &self.lines
    }
}

fn main() {
    let reader = Reader::new();
    let mut main_vector: Vec<Vec<&str>> = Vec::new();
    for line in reader.lines() {
        match line {
            Ok(v) => {
                let mut sub_vector: Vec<&str> = Vec::new();
                for element in v.split_whitespace().collect::<Vec<&str>>() {
                    sub_vector.push(element);
                }
                main_vector.push(sub_vector);
            },
            Err(e) => panic!("failed to parse: {:?}", e),
        }
    }
}

类型错误=i32；
结构读取器
{
线路：Vec
}
impl阅读器
{
pub fn new（）->Self
{
Self{lines:vec！[Ok（“foo.into（）），Ok（“bar.into（））]]
}
发布fn行（&self）->和[结果]
{
&自选线
}
}
fn main（）{
让reader=reader:：new（）；
让mut main_vector:Vec=Vec:：new（）；
对于读卡器中的行。行（）{
火线{
Ok（v）=>{
让mut sub_vector:Vec=Vec:：new（）；
对于v.split_whitespace（）中的元素。collect:：（）{
子向量推（元素）；
}
主向量推（子向量）；
},
Err（e）=>panic！（“未能分析：{:？}”，e），
}
}
}

---

您可以在此处查看此问题

此问题类似于。最简单的解决方案与问题中的相同-使用字符串，而不是&str。 这些问题是不同的，因为这个答案专门谈论从函数返回，而您没有列出任何函数

要解决生命周期导致代码失败的原因，请尝试一个更简单的示例

fn main（）{
让mut v:Vec=Vec:：new（）；
{
设chars=[b'x'，b'y'，b'z']；
设s:&str=std:：str:：from_utf8（&chars）.unwrap（）；
v、 推送（&s）；
}
println！（“{：？}”，v）；
}

和编译器输出

let s:&str = std::str::from_utf8(&chars).unwrap();
                                 ^^^^^^ borrowed value does not live long enough

---

这不起作用的原因正是编译器所说的<代码>字符是在块内创建的，因此它会获得与该块关联的生存期，当程序退出该块时，字符可能不再存在。任何引用

字符的内容都可能有一个悬空指针。Rust通过将指针设置为非法来避免指针悬空。在我的例子中，Rust不允许这样做似乎很愚蠢，但在你的例子中，这是有道理的——Rust可以通过从
v.split_whitespace（）中删除旧的
str
s来保持堆栈较小。collect:：（）
每次通过循环。
我已经添加了代码的其他部分。这个代码段运行得很好，但我认为BufReader（
.lines（）
）是问题所在。它通过使用
Vec
而不是
Vec
来解决。非常感谢。

let s:&str = std::str::from_utf8(&chars).unwrap();
                                 ^^^^^^ borrowed value does not live long enough