Rust for cpp devs - 生命周期

生命周期（lifetime）也是一类泛型。但它是用于指定引用保持有效的作用域。

Rust 中的每个引用都有相应的 lifetime。大部分时候，lifetime 可以被编译器推断出来，无需手动指明，就像类型推断一样。同样的，当编译器无法确定 lifetime 时，Rust 要求开发者指明。主要目的就是在编译期保证不存在悬垂引用。

Generic Lifetimes in Functions

我们从一段简单的代码入手理解 lifetime。这是一个返回较长字符串的函数：

fn longest(x: &str, y: &str) -> &str {
    let longer = if x.len() > y.len() {x} else {y};
    return longer
}

fn main() {
    let s1 = String::from("abcd");
    let s2 = "xyz";
    let result = longest(s1.as_str(), s2);
    println!("The longer string is {}", result);
}

这是一个简单的函数，但是编译时会报错：

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:33
  |
1 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
1 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ^^^^    ^^^^^^^     ^^^^^^^     ^^^

其原因是 Rust 无法确定其 lifetime。这是由于 x y 都是来自于函数外的引用，编译器无法推断出参数和返回值的 lifetime。因此，我们需要手动标记参数和返回值的 lifetime。

什么是生命周期（非教材内容）

生命周期的表示方法是 ' 加生命周期的名字，一般接在引用符号 & 后。例如：

&i32        // a reference
&'a i32     // a reference with an explicit lifetime
&'a mut i32 // a mutable reference with an explicit lifetime

本节主要是一些补充知识，有助于更好地从本质理解 lifetime。

生命周期也是一种类型，长生命周期是短生命周期的子类型。 我们可以用 : 来标记这种父子关系。例如'b 长于 'a，可以记作 'b: 'a。

生命周期以模板形式，为函数额外传入了变量的生命周期。

生命周期的标记不影响变量的生命周期。标记只是为编译器里的 borrow checker 明确该如何检查生命周期。

在函数签名中标记生命周期

我们实际上需要解决的问题是，已知 x 的 lifetime 是 'a，y 的 lifetime 是 'b，那么返回值的 lifetime （假设是 'c）怎么通过 'a 和 'b 表示？

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'c str {
    let longer = if x.len() > y.len() {x} else {y};
    return longer
}

显然，我们需要让 'c 取 'a 和 'b 的交集，即较小的那个。因此必然有 'a: 'c 和 'b: 'c。既然 'a 和 'b 都是 'c 的父类型，那么可以直接把参数中的 'a 和 'b 替换为 'c：

fn longest<'c>(x: &'c str, y: &'c str) -> &'c str {
    let longer = if x.len() > y.len() {x} else {y};
    return longer
}

这样写相当于告诉编译器，返回值的 lifetime 是参数 lifetime 的公共父类型，即交集。

明确了函数参数和返回值的 lifetime 后，编译器在函数调用者处就有了足够的信息来检验生命周期。

结构体定义中的 lifetime 标记

结构体也可以持有变量的“引用”而非”所有权“。例如：

struct ImportantExcerpt {
    part: &str,
}

但是这段代码无法编译，因为：

error[E0106]: missing lifetime specifier
 --> src/main.rs:7:11
  |
7 |     part: &str,
  |           ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
6 | struct ImportantExcerpt<'a> {
7 |     part: &'a str,
  |

这是因为当结构体持有变量的引用时，我们需要指定 lifetime 标记：

struct ImportantExcerpt<'a> {
    part: &'a str,
}

其含义是，ImportantExcerpt 存在的生命周期必须包含于 part 引用的生命周期。

省略生命周期

我们已经知道在 Rust 中：

• 每个引用都有对应的 lifetime
• 使用引用时，需要指定 lifetime

但是，我们确实曾经写过没有标注生命周期的函数。例如：

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

在 Rust 1.0 之前，这段代码确实会编译失败。因为每个引用都需要一个显式指定的生命周期。后来，Rust 开发人员将可以推断 lifetime 的模式写进了编译器代码，对于这些模式，不再需要手动指定。

如果满足下面三个条件，Rust 就可以推断生命周期，无需手动指定，否则，Rust 会在编译时报错：

1. 为每个引用参数赋予 lifetime

2. 如果只有一个参数，这个参数的 lifetime 会作为所有返回值的 lifetime

3. 如果有多个参数，但是其中之一是 &self 或 &mut self（类方法），则返回值的 lifetime 与 self 一致

例如，对于 first_word 函数：

fn first_word(s: &str) -> &str {

编译器首先执行，为参数赋予生命周期 'a（Rule 1）：

fn first_word(s: &'a str) -> &str {

由于只有一个参数，它的 lifetime 被直接赋值给返回值（Rule 2）：

fn first_word<'a>(s: &'a str) -> &'a str {

现在所有引用都有了 lifetime，所以编译器不需要开发者指定 lifetime 了。

与之相对，对于 longest 函数：

fn longest(x: &str, y: &str) -> &str {

首先为每个输入赋予 lifetime （Rule 1）：

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {

Rule 2 不适用，因为有两个不同的输入 lifetime。

Rule 3 也不适用，因为 longest 不是一个类方法，不存在 self。

因此编译器无法确定返回值的 lifetime，只能要求开发者指定。

生命周期与泛型

因为 lifetime 是一种泛型，所以 'a 和 T 可以写在同一个 <> 中。

fn longest_with_an_announcement<'a, T: Display>(x: &'a str, y: &'a str, ann: T) -> &'a str {
    println!("Announcement! {}", ann);
    let longer = if x.len() > y.len() { x } else { y };
    return longer;
}