Rust &引用；“变量的寿命不够长”；当返回一个包含引用的结果时，但它确实存在足够长的时间

我正在实现一个小实用程序，编译器告诉我一个变量（a

TcpStream

）的寿命不够长，并建议我找到一种方法，使它的寿命与当前的寿命完全相同

错误消息

错误[E0597]：`stream`的寿命不够长
-->src/main.rs:47:35
|
47 |匹配句柄_请求（&mut流）{
|^^^^^^^借来的价值寿命不够长
...
54 | }
|-借来的价值仅在此处有效
|
注意：借用值必须对函数体上定义的匿名生存期（43:1）有效。。。
-->src/main.rs:43:1
|
43 |/fn handle_数组（流：&mut BufReader）->结果
44 | | {
45 | |让mut数组：Vec=Vec:：with_capacity（50）；//任意大小，在整个程序中以不同方式拾取
46 | |对于0..50中的| x{
...  |
53 | | Ok（数据：：数组（数组））
54 | | }
| |_^

代码

使用std:：collections:：HashMap；
使用std:：io:：BufReader；
使用std:：io:：Read；
使用std:：net:：TcpStream；
静态令牌：&[u8；2]=b“\r\n”；
fn main（）{}
#[派生（调试、克隆）]
发布枚举数据{
字符串（Vec），
误差（Vec），
整数（i64），
二进制（Vec），
阵列（Vec），
字典（HashMap），
}
#[派生（调试、克隆）]
发布枚举错误结果{
//TODO处理空流
让mut buff:[u8；1]=*b“0”；
stream.read_exact（&mut buff）；//TODO:在此处处理错误
匹配与增益{
/*跳过部分，不相关*/
b“*”=>句柄数组（流），
&[\u]=>Err（Errors:：CommandError（“错误请求”），
}
}
/*跳过部分，不相关*/
fn handle_数组（流：&mut BufReader）->结果{
让mut数组：Vec=Vec:：with_capacity（50）；//任意大小，在完整程序中以不同方式拾取
对于0..50中的x{
匹配句柄请求（&mut流）{
确定（x）=>array.push（x.clone（）），
Err（x）=>返回Err（x.clone（）），
}
}
Ok（数据：：数组（数组））
}

我真的被这件事难住了

似乎我不能使用Err的值。如果我替换

match handle_request(&mut stream){
    Ok(x) => array.push(x.clone()),
    Err(x) => return Err(x.clone()),
}

与

---

问题解决了，但我不知道为什么。

您的问题可以归结为：

struct Reader;
struct Data;
struct Errors<'a>(&'a str);

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    for _ in 0..0 {
        handle_request(&mut stream)?;
    }

    unimplemented!();
}

fn handle_request(_stream: &mut Reader) -> Result<Data, Errors> {
    unimplemented!()
}

fn main() {}

handle\u request

需要一个

&mut读取器

，因此编译器会插入一些代码来为您对齐这两种类型。编译器在执行此转换时必须保守，因此它会选择较短的生存期：

fn handle_array<'stream>(stream: &'stream mut Reader) -> Result<Data, Errors> {
    let tmp: &'tmp mut &'stream mut Reader = &mut stream;
    let tmp2: &'tmp mut Reader = tmp;
    if let Err(x) = handle_request(tmp2)

不幸的是，这只会更改错误：

error[E0499]：不能一次多次将“*stream”作为可变项借用
-->src/main.rs:9:40
|
9 |如果让错误（x）=处理请求（流）{
|^^^^^^可变借用在循环的上一次迭代中从这里开始
...
15 | }
|-可变借用结束于此

这一部分更难解释。请参阅：

• 本课程的“问题案例#3”

这是一个非常粗糙的生锈边缘，但它越来越接近被修复！然而，现在，你有两个主要的选择：

调用函数两次 这可能不起作用，因为您无法从流中读取两次，但在其他情况下，它可能会很有用：

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let mut array = vec![];
    for _ in 0..0 {
        if handle_request(stream).is_err() {
            return handle_request(stream);
        }
        if let Ok(r) = handle_request(stream) {
            array.push(r);
        };
    }

    unimplemented!();
}

fn handle\u数组（流：&mut读取器）->结果{
让mut数组=vec！[]；
对于0..0中的uu{
if handle_request（stream）.is_err（）{
返回句柄请求（流）；
}
如果让Ok（r）=处理请求（流）{
推（r）；
};
}
未执行！（）；
}

删除引用 现在放弃在这种情况下尝试引用

struct错误（字符串）；
fn handle_数组（流：&mut读取器）->结果{
让mut数组=vec！[]；
对于0..0中的uu{
array.push（处理请求（流）；
}
未执行！（）；
}

为了提高效率，我会使用迭代器编写：

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let array = (0..0)
        .map(|_| handle_request(stream))
        .collect::<Result<Vec<_>, _>>()?;

    unimplemented!();
}

fn handle\u数组（流：&mut读取器）->结果{
让数组=（0..0）
.map（| |句柄|请求（流））
收集：：（）？；
未执行！（）；
}

未来？ 使用不稳定的NLL功能和实验性的“钋”实现，此代码可以工作：

struct Errors<'a>(&'a str);

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let mut array = vec![];
    for _ in (0..0) {
        array.push(handle_request(stream)?);
    }

    unimplemented!();
}

struct错误结果{
让mut数组=vec！[]；
对于（0..0）中的uu{
array.push（处理请求（流）；
}
未执行！（）；
}

---

这将是一段时间之前，这是普遍可用的…

@Shepmaster现在更好了吗？我真的想让这是正确的方式：）此外，为什么有这么多的枚举变量；它们都需要吗？需要调用各种函数吗？是否使用了

令牌

等等…现在它编译，我会简化它更多。你是r是的，它仍然臃肿。刚刚找到了一个解决方案，我将继续简化此代码，并在我找到我的“解决方案”工作的确切原因后尽快发布解决方案。非常感谢，我似乎在rust中还有很多东西要学。反应很好，有很多细节；我想不到有更好的：）

handle_request(stream)?;

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let mut array = vec![];
    for _ in 0..0 {
        if handle_request(stream).is_err() {
            return handle_request(stream);
        }
        if let Ok(r) = handle_request(stream) {
            array.push(r);
        };
    }

    unimplemented!();
}

struct Errors(String);

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let mut array = vec![];
    for _ in 0..0 {
        array.push(handle_request(stream)?);
    }

    unimplemented!();
}

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let array = (0..0)
        .map(|_| handle_request(stream))
        .collect::<Result<Vec<_>, _>>()?;

    unimplemented!();
}

struct Errors<'a>(&'a str);

fn handle_array(stream: &mut Reader) -> Result<Data, Errors> {
    let mut array = vec![];
    for _ in (0..0) {
        array.push(handle_request(stream)?);
    }

    unimplemented!();
}