rust - 为什么我在函数外部不需要的值会出现 "Borrowed value does not live long enough"错误？

Question

为什么会出现这种情况？我是 Rust 的新手，阅读了第 2 版书，但是......好吧，是的，我在这里。 :)

fn main() {
    Xyz::new(&"whatever=123");
}

pub struct Xyz<'a> {
    x: &'a str
}

impl<'a> Xyz<'a> {
    pub fn new(query: &str) -> Result<Xyz<'a>, &'a str> {
        let mut qkey: String = String::new();
        let mut qval: String = String::new();

        let mut is_key = true;
        for (i, c) in query.chars().enumerate().skip(1) {
            if c == '=' {
                is_key = false;
            } else if c == '&' {
                is_key = true;
            } else if is_key {
                qkey.push(c);
            } else {
                qval.push(c);
            }

            if c == '&' || i == query.len() - 1 {
                match qkey.as_ref() {
                    "whatever" => {
                        let _whatever = Xyz::some_func(&mut qval)?;
                    }
                    _ => (),
                }

                qkey.clear();
                qval.clear();
            }
        }
        Ok(Xyz { 
            x: &""
        })
    }

    fn some_func(_val: &mut String) -> Result<bool, &str> {
        Ok(true)
    }
}

playground

错误:

error[E0597]: `qval` does not live long enough
  --> src/main.rs:29:61
   |
29 |                         let _whatever = Xyz::some_func(&mut qval)?;
   |                                                             ^^^^ borrowed value does not live long enough
...
41 |     }
   |     - borrowed value only lives until here
   |
note: borrowed value must be valid for the lifetime 'a as defined on the impl at 9:1...
  --> src/main.rs:9:1
   |
9  | impl<'a> Xyz<'a> {
   | ^^^^^^^^^^^^^^^^

我不明白为什么会发生实际错误。我知道该说明应该可以帮助我理解问题，但事实并非如此。

在这个函数之外我不需要qval，那么为什么我还要保留它呢？我犯了概念性错误吗？

Answer 1

您问题的缩减复制是

pub struct Xyz<'a> {
    x: &'a str
}

impl<'a> Xyz<'a> {
    pub fn new(_query: &str) -> Result<Xyz<'a>, &'a str> {
        let qval: String = String::new();

        Err(&qval)
    }
}

错误

error[E0597]: `qval` does not live long enough
  --> src/main.rs:13:18
   |
13 |             Err(&qval)
   |                  ^^^^ borrowed value does not live long enough
14 |         }
   |         - borrowed value only lives until here

要理解这一点，我建议退后一步，想想您的函数到底在做什么。您创建一个 String ，然后引用它，然后返回该引用。

这将是 use-after-free 的经典案例.从语言的角度来看，该字符串已不存在，因此返回对它的引用没有意义。

返回 &str 可以有意义，但前提是您可以保证 &str只会引用仍在范围内的数据，即使在函数返回之后也是如此。例如，执行 Err(&query) 是有效的(或 query 的任何小节)如果您将函数调整为 fn new(query: &'a str) -> ，从那时起就知道返回值与输入字符串一样长。

很难从您的示例中判断这对于用例是否可以接受。

最简单确实是返回一个String (或在您的情况下为 Result<Xyz<'a>, String>>，也可能在 String 的字段中带有 Xyz)。您还可以考虑返回类似 Cow 的内容这是有时 query 的一个小节或静态字符串，有时 String .

作为旁注，我还要添加 Xyz::new(&"whatever=123");不需要 &因为它已经是一个引用。你可以做

Xyz::new("whatever=123");

就好了。同样适用于 &"" .

My confusion was that - in the not stripped down version - both function (new and some_func returned a global &'static str as Err, so I thought the compiler would know that the string would always exist.

这可能是误解的核心。当你声明

fn some_func(_val: &mut String) -> Result<bool, &str> {

&str不是 'static .使用rust 的 lifetime elision逻辑意味着这个声明将假定函数参数中的引用和返回值中的引用具有相同的生命周期，这意味着你声明的是

fn some_func<'b>(_val: &'b mut String) -> Result<bool, &'b str> {

这会触发您看到的错误。如果你希望它是静态的，你需要这样说，因为

fn some_func(_val: &mut String) -> Result<bool, &'static str> {

这将避免错误，并要求 some_func总是返回 'static字符串。