结构的所有字段的生存期参数相同

Question

以下是代码：

#[derive(Debug)]
struct Foo {
    f: i32,
}
#[derive(Debug)]
struct Bar<'a> {
    bar1: &'a Foo,
    bar2: &'a Foo,
}
#[allow(unused_variables)]
fn make_bar<'a>(foo1: &'a Foo, foo2: &'a Foo) -> Bar<'a> {
    Bar {
        bar1: foo1,
        bar2: foo2,
    }
}
fn extract_bar2<'a>(foo: &'a Foo) -> &'a Foo {
    let foo1 = Foo { f: 22 };
    let foo2 = make_bar(&foo, &foo1).bar1;
    foo2
}
fn main() {
    let foo = Foo { f: 11 };
    let foo1 = extract_bar2(&foo);
    println!("foo1: {:?}", foo1);
}

这会产生一个错误：

error: `foo1` does not live long enough
  --> src/main.rs:23:32
   |>
23 |>     let foo2 = make_bar(&foo, &foo1).bar1;
   |>                                ^^^^
note: reference must be valid for the lifetime 'a as defined on the block at 21:45...
  --> src/main.rs:21:46
   |>
21 |> fn extract_bar2<'a>(foo: &'a Foo) -> &'a Foo {
   |>                                              ^
note: ...but borrowed value is only valid for the block suffix following statement 0 at 22:29
  --> src/main.rs:22:30
   |>
22 |>     let foo1 = Foo { f: 22 };
   |>                              ^

核心问题是：在结构的上下文中，生存期参数实际上意味着什么？

更具体地说：对结构的所有字段使用相同的生存期参数会产生什么后果？他们的一生必须完全一样吗？它们必须重叠吗？如果是，它们应该在多大程度上重叠？

以下两种结构在语义和实践上有什么区别？

struct Bar<'b> {
    bar1: &'b Foo,
    bar2: &'b Foo,
}
struct Bar<'a, 'b> {
    bar1: &'a Foo,
    bar2: &'b Foo,
}

Answer 1

遵循两个结构？

有一个小例子来证明这种差异：

#[derive(Debug)]
struct Foo;
#[derive(Debug)]
struct Bar1<'b> {
    foo1: &'b Foo,
    foo2: &'b Foo,
}
#[derive(Debug)]
struct Bar2<'a, 'b> {
    foo1: &'a Foo,
    foo2: &'b Foo,
}
fn main() {//'a -->
    let foo1 = Foo;
    let ref_foo1 = 
    {//'b -->
        let foo2 = Foo;
        //error: `foo2` does not live long enough
        //replace the Bar1 with Bar2 in the row below to fix error 
        let bar = Bar1{foo1:&foo1, foo2:&foo2};
        bar.foo1
    };//--> 'b
    println!("ref_foo1={:?}", ref_foo1);
}//--> 'a

Bar1将其成员的生存期截断到它们的交集。因此，您无法从Bar1结构中获得对具有生存期'a的foo1的引用。您可以获得终身'b的参考。

我应该注意，这种情况下的错误消息有点误导

Answer 2

我将从reddit粘贴一个我非常满意的答案。

编译器可以通过取它们的交集来组合生存期。也就是说，如果你有'a和'b，那么'a和'b有一个交集'c，在这个交集中，两个寿命都是"活着的"。我相信，由于范围界定的工作方式，这个交集总是等于"a"one_answers"b"中的最短值，但也许我错了。

在实践中，这意味着，当你看到fn<'a>(x: &'a T, y: &'a U) -> &'a V时，你可以放入&'static T和&'b U，你会得到&'b V，因为'static和'b的交集是'b。

那么，为什么您的方法会导致编译器抱怨呢？因为对于编译器来说，它看起来有点像这样(这不是有效的语法(：

fn extract_bar2<'a>(foo: &'a Foo) -> &'a Foo {
    'b: {
        let foo1 = Foo { f: 22 };
        'c: { // The next line is wrong
            let foo2: &'a Foo = make_bar<'a>(&'a foo, &'b foo1).bar1;
            'd: {
                return foo2;
            }
        }
    }
}

我已经使作用域更加明确。会发生什么？编译器知道foo2的类型必须是&'a Foo，因为这就是函数返回的类型。所以make_Bar返回的Bar一定有生存期'a：否则我们无法从中获得&'a Foo。所以我们一定打电话给make_bar<'a>了。但其中一个论点是错误的！foo2没有寿命'a，它有寿命'b，寿命比'a长。如果你在十字路口这样做：

    let foo2: &'b Foo = make_bar<'b>(&'a foo, &'b foo1).bar1;

则CCD_ 26与返回类型不匹配。

当您使用Bar的第二个定义时，代码将起作用，因为在这种情况下，bar1和bar2不需要具有相同的生存期。因此，您的第二个Bar定义严格来说更灵活，但在实践中，您很少需要额外的灵活性，而且额外的生存期注释很烦人。

贷记至https://www.reddit.com/user/thiez