通用生命周期是作为引用的生命周期还是被引用值的生命周期实现？

Question

考虑以下程序：

fn main() {
    let c;                                      |<-'a
    let mut a = "Hello, world!".to_string();    |
    {                                           |
        let b = &mut a;           |<-'b         |
        c = foo(b);               |             |
    }                                           |
    println!("{}", c)                           |
}

fn foo<'z>(a: &'z mut str) -> &'z str {
    a
}

b 的生命周期是 'b，但 c 的生命周期是 'a，比 'b 长。 foo 的生命周期约束表明 foo 的返回值（本例中为 c）与其参数（本例中为 b）应具有相同的生命周期。 foo 的生命周期约束如何满足？

但是，这个程序可以编译，所以我猜 foo 的生命周期参数 'z 实现为 b 的引用值 (a) 的生命周期，因此满足 foo 的生命周期约束?

Answer 1

值有自己的生命周期，但引用也跟踪它所引用的事物的生命周期。不幸的是，这里缺少官方术语。我（和其他一些人）开始使用的术语是具体的生命周期。 main 中有三个变量，因此有三个具体的生命周期：

fn main() {
    let c;                     //       'c
    let mut a = String::new(); // 'a     ¦
    {                          //  |     ¦
        let b = &mut a;        //  | 'b  ¦
        c = foo(b);            //  |  |  |
    }                          //  |     |
    println!("{}", c)          //  |     |
}

a 是 String，b 是 &mut String，c 是 &str。所有三个变量都是值，但b 和c 也是 引用。这里b指的是a中的值，是&'a mut String。由于c 派生自b，因此它具有相同的“内部生命周期”：&'a str。

值得注意的是，b 本身的生命周期从不发挥作用。它非常罕见，因为您需要有可变借用和“额外”借用：

fn main() {
    let c;
    let mut a = String::new();
    {
        let mut b = &mut a;
        c = foo(&mut b);    // Mutably borrowing `b` here
    }
    println!("{}", c)
}

error[E0597]: `b` does not live long enough
 --> src/main.rs:6:17
  |
6 |         c = foo(&mut b);
  |                 ^^^^^^ borrowed value does not live long enough
7 |     }
  |     - `b` dropped here while still borrowed
8 |     println!("{}", c)
  |                    - borrow later used here

在这种情况下，传递给foo 的值是&'b mut &'a mut String 类型，它被强制转换为&'b mut str。 b 的值不够长，您会收到错误消息。

我认为这种模型无法解释更复杂的借贷关系。如果a在println!之后再次使用，例如，可变借用不能持续a的整个生命周期

a 的可变借用由c 持有，但借用的持续时间不需要与c 的生命周期相对应。由于non-lexical lifetimes（在这种情况下更好地称为“非词法借用”），c 持有的a 的借用可以在println! 之后但在作用域结束之前终止。

增强上面的图表以显示 value 的生命周期以及括号中 referred-to value 的生命周期：

fn main() {
    let c;                     //           'c
    let mut a = String::new(); // 'a         ¦
    {                          //  |         ¦
        let b = &mut a;        //  | 'b('a)  ¦
        c = foo(b);            //  |  |('a)  |('a)
    }                          //  |         |('a)
    println!("{}", c);         //  |         |('a)
                               //  |         |
    println!("{}", a);         //  |         |
}

另见：

• Why does linking lifetimes matter only with mutable references?
• How can this instance seemingly outlive its own parameter lifetime?
• Mutable borrow in a getter not living long enough
• Reference does not live long enough in nested structure
• Cannot borrow as mutable more than once at a time in one code - but can in another very similar
• What is the difference between '&self' and '&'a self'?