rust - 引用在嵌套结构中的生命周期不够长

Question

我正在创建一系列数据结构，其中包含对较低级别结构的可变引用。我一直很高兴地使用下面的 A、B 和 C，但我尝试添加一个新层 D 。 A, B, C, D其实就是一个协议(protocol)解码的状态机的状态，但是我'我在这里删除了所有内容:

struct A {}

fn init_A() -> A {
    A {}
}

struct B<'l> {
    ed: &'l mut A,
}

fn init_B(mut e: &mut A) -> B {
    B { ed: e }
}

struct C<'l> {
    pd: &'l mut B<'l>,
}

fn init_C<'l>(mut p: &'l mut B<'l>) -> C<'l> {
    C { pd: p }
}

struct D<'lifetime> {
    sd: &'lifetime mut C<'lifetime>,
}

fn init_D<'l>(mut p: &'l mut C<'l>) -> D<'l> {
    D { sd: p }
}

fn main() {
    let mut a = init_A();
    let mut b = init_B(&mut a);
    let mut c = init_C(&mut b);

    // COMMENT OUT THE BELOW LINE FOR SUCCESSFUL COMPILE
    let mut d = init_D(&mut c);
}

我得到一个错误:

error[E0597]: `c` does not live long enough
  --> src/main.rs:38:1
   |
37 |     let mut d = init_D(&mut c);
   |                             - borrow occurs here
38 | }
   | ^ `c` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

就生命周期而言，我完全不了解 D 与 C 发生的不同之处:我不明白生命周期不匹配是什么。

Answer 1

我将解决问题代码不起作用的原因。

TL;DR:类型生命周期的不变性 C<'l>和 D<'l>并且对它们使用单​​个生命周期参数 ( 'l ) 会导致这些类型的变量在变量 b 期间保持借用。存在，但变量 c (由 d 借用)在 b 之前删除.

借用检查器本质上是一个约束求解器。它搜索满足各种约束的最短生命周期⁰:引用的生命周期不得超过其引用的值，生命周期必须遵守函数签名和类型中指定的约束条件，并且生命周期必须遵守方差规则¹。

0 — 引用的最短生命周期是最好的，因为这样引用就不会借用一个值超过必要的时间。

1 — Rust 有一个概念 variance这决定了是否可以在预期生命周期较短的地方使用生命周期较长的值。 Rustonomicon 链接对其进行了详细解释。

下面的代码是相关代码的简化版本，它失败并出现相同的错误:c活得不够长。这些 block 标有变量的生命周期。 'a是变量的生命周期 a等等。这些生命周期由代码的结构决定，并且是固定的。

类型注释中的生命周期(B(&'ar A) -> B<'ar> 等等)是变量。借用检查器尝试为这些变量找到固定生命周期('a、'b、'c、'd)的有效分配。

let下方的评论语句显示生命周期限制，我将在下面解释。

struct A;

struct B<'l>(&'l mut A);

struct C<'l>(&'l mut B<'l>);

struct D<'l>(&'l mut C<'l>);

fn main() {
    // lifetime 'a
    let mut a = A;
    { // lifetime 'b
        // B(&'r mut A) -> B<'ar>   
        let mut b = B(&mut a); 
        // 'r >= 'ar & 'r <= 'a
        { // lifetime 'c
            // C(&'br mut B<'ar>) -> C<'abr>  
            let mut c = C(&mut b); 
            // 'br <= 'b & 'abr = 'ar & 'br >= 'abr
            { // lifetime 'd
                // D(&'cr mut C<'abr>) -> D<'cabr> 
                let d = D(&mut c); 
                // 'cr <= 'c & 'cabr = 'abr & 'cr >= 'cabr
            }
        }
    }
}

第一次作业

// B(&'r mut A) -> B<'ar>   
let mut b = B(&mut a); 
// 'r <= 'a & 'r >= 'ar

引用a活不过a ，因此 'r <= 'a .

&'r mut A是 'r 的变体，因此我们可以将它传递给 B<'ar> 的类型构造函数期望 &'ar mut A比较 'r >= 'ar .

第二次作业

 // C(&'br mut B<'ar>) -> C<'abr>  
 let mut c = C(&mut b); 
 // 'br <= 'b & 'abr = 'ar & 'br >= 'abr

引用不能超过 b ( 'br <= 'b ), &mut B在 B 上不变( 'abr = 'ar ), &'br mut B是 'br 的变体( 'br >= 'abr )

d的分配类似于 c .

Rust 似乎没有将它尚未遇到的生命周期视为可能的分配。 'ar 的可能分配因此是'a或 'b , 'abr 的那些是'a , 'b , 或 'c等等。

这组约束归结为 'ar = 'abr = 'cabr和 'ar 的最小允许分配是'b .因此 b 的类型, c , 和 d是B<'b> , C<'b> , D<'b> .即变量d持有对 c 的引用终生'b ，但是c被丢弃在 'c 的末尾生命周期。

如果我们删除 d , 然后 c仍然保持b借到生命尽头'b , 但这不是问题，因为 b不会超过生命周期 'b .

这个描述还是很简化的。例如，虽然 c 的类型是C<'b> , c不借b终生'b , 它借用了 'b 的一部分在 c 的定义之后开始, 但这是我还没有清楚的理解。