从具有自链接生命周期的可变引用获取不可变引用时有什么区别？

Question

struct Foo01<'a> {
    val: u32,
    str: &'a String,
}

fn mutate_and_share_01<'a>(foo: &'a mut Foo01<'a>) -> &'a Foo01<'a> {
    foo
}

fn mutate_and_share_02<'a>(foo: &'a mut Foo01<'a>) -> &'a Foo01 {
    foo
}

fn mutate_and_share_03<'a>(foo: &'a mut Foo01) -> &'a Foo01<'a> {
    foo
}

fn main() {
    let mut foo = Foo01 { val: 16, str: &String::from("Hello ") };
    let foo_mut = &mut foo;

    //let loan = mutate_and_share_01(foo_mut);
    //let loan2 = mutate_and_share_01(foo_mut); //error

    //let loan = mutate_and_share_02(foo_mut);
    //let loan2 = mutate_and_share_02(foo_mut); //error

    let loan = mutate_and_share_03(foo_mut);
    let loan2 = mutate_and_share_03(foo_mut); //good
}

这些mutate_and_share 版本之间有什么区别？

Answer 1

在情况 1 和 2 中，您是说只要结构借用其参数，函数就会借用结构：

foo: &'a mut Foo01

这表示“foo 是从 'a 借来的”（&'a mut）和“foo 借用它的参数为 'a”（Foo01<'a>）。

就 rustc 而言，这意味着调用此函数必然会永远借用输入，因为结构必然会在其整个生命周期内借用 其 输入，因此您会被锁定：您不能通过删除输入来“取消借用”输入，因此第二次调用永远无法工作。

在情况 3 中，您将 输出 的参数与内部借用相关联，这不是真的，但至少在这种情况下工作得很好。事实上，这两个生命是无关的：

fn mutate_and_share<'a, 'b>(foo: &'a mut Foo01<'b>) -> &'a Foo01<'b> {
    foo
}

还请注意，您的第三种情况仅适用，因为您从未使用 loan，因此在第二行执行之前立即将其删除。如果你这样做：

    let loan = mutate_and_share_03(foo_mut);
    let loan2 = mutate_and_share_03(foo_mut); //good
    print("{}", loan.val)

那么它不会编译，因为可变借用是重叠的。

哦，&String 通常没用。 &mut String 有一些用例，但任何时候您看到对 String 的不可变引用时，最好使用 &str。和&Vec<T>一样，没用，应该是&[T]。