rust - 泛型生命周期具体化为引用的生命周期还是引用值的生命周期？

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变海峡。值 b 的生命周期不够长，您会收到错误。

I don't think this model can account for more complicated borrowing relationships. If a is used again after the println!, for example, the mutable borrow can't be for the entire lifetime of a

a 的可变借用由 c 持有，但借用的持续时间 不需要对应于c。由于 non-lexical lifetimes (在这种情况下更好地称为“非词汇借用”)，c 持有的 a 的借用可以在 println! 之后但之前终止范围结束。

增强上面的图表以在括号中显示值的生命周期和引用值的生命周期:

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'?