Rust 学习笔记：生命周期

Rust 学习笔记：生命周期

• [Rust 学习笔记：生命周期](#Rust 学习笔记：生命周期)
• • 使用生命周期防止悬空引用
  • 借用检查器
  • 函数中的泛型生命周期
  • 生命周期注释语法
  • 函数签名中的生命周期注解
  • 从生命周期的角度思考
  • 结构定义中的生命周期注解
  • 省略生命周期
  • 方法定义中的生命周期注释
  • 静态生命周期
  • [泛型类型参数、trait 约束和生命周期](#泛型类型参数、trait 约束和生命周期)

Rust 学习笔记：生命周期

生命周期是我们已经使用过的另一种泛型。

生命周期不是确保类型具有我们想要的行为，而是确保引用在我们需要时有效。

Rust 中的每个引用都有生命周期，也就是引用有效的范围（作用域）。

大多数时候，生命周期是隐式的和推断的，就像大多数时候，类型是推断的一样。只有当可能有多个类型时，我们才需要注释类型。

以类似的方式，当引用的生命周期可能以几种不同的方式相关联时，我们必须注释生命周期。Rust 要求我们使用泛型生命周期参数注释关系，以确保在运行时使用的实际引用肯定是有效的。

使用生命周期防止悬空引用

生命周期的主要目的是防止悬空引用，悬空引用会导致程序引用的数据不是它想引用的数据。

考虑下面的程序，它有一个外部作用域和一个内部作用域。

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {r}");
}

错误信息：

外部作用域声明了一个名为 r 的变量，没有初始值，而内部作用域声明了一个名为 x 的变量，初始值为 5。在内部作用域中，我们尝试将r的值设置为对 x 的引用。然后，内部作用域结束，我们尝试在 r 中打印该值。

这段代码无法编译，因为 r 的生命周期比 x 更长，引用了 x 超出作用域时被释放的内存。

那么 Rust 如何判断这段代码是无效的呢？它使用借用检查器。

借用检查器

Rust 编译器有一个借用检查器，用于比较作用域以确定是否所有借用都有效。

借用检查器确保数据存活的时间长于其引用（Outlive）。

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {r}");   //          |
}       

这里，我们用 'a 注释了 r 的生命周期，用 'b 注释了 x 的生命周期。内部的 'b 块比外部的 'a 生命周期块要小得多。在编译时，Rust 比较两个生命周期的大小，发现 r 的生命周期为 'a，但它引用的内存的生命周期为 'b。程序被拒绝，因为 'b 比 'a 短，即数据（引用的主体）没有引用的生命周期长。

修正程序：

fn main() {
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {r}");   //   |       |
                          // --+       |
}                         // ----------+

这里，x 的生命周期为 'b，在这种情况下大于 'a。这意味着 r 可以引用 x，因为 Rust 知道 r 中的引用总是有效的，而 x 是有效的。

函数中的泛型生命周期

我们尝试编写一个函数，输入两个字符串切片，返回两个字符串切片中较长的那个。

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

编译报错了：

帮助文本表明，返回类型需要一个泛型生命周期参数，因为 Rust 无法判断被返回的引用是指向 x 还是 y。实际上，我们也不知道，因为这个函数体中的if块返回对x的引用，而else块返回对y的引用！

当我们定义这个函数时，我们不知道传入的引用的具体生存期，也不知道函数返回 x 的引用还是 y 的引用，因此不能通过查看作用域的方式确定返回的引用是否始终有效。借用检查器也无法确定这一点，因为它不知道 x 和 y 的生存期与返回值的生存期之间的关系。

为了修复这个错误，我们将添加泛型生命周期参数来定义引用之间的关系，以便借用检查器可以执行其分析。函数修改如下：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

为什么这样写，后面有解释，我们先了解生命周期注释语法。

生命周期注释语法

生存期注释不会改变任何引用的生存时间。相反，它们描述了多个引用之间的生命周期关系。

正如当签名指定泛型类型参数时，函数可以接受任何类型一样，通过指定泛型生命周期参数，函数可以接受具有任何生命周期的引用。

生命周期注释的语法略有不同：生命周期参数的名称必须以撇号（'）开头，并且通常都是小写且非常短，就像泛型类型一样。大多数人使用名称 'a 作为第一个生命周期注释。我们将生命周期形参注释放在引用的 & 之后，使用空格将注释与引用的类型分开。

这里有一些例子：

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

一个生命周期注释本身没有太多意义，因为注释的目的是告诉 Rust 多个引用的泛型生命周期参数是如何相互关联的。

让我们来看看在 longest 函数的上下文中，生命周期注释是如何相互关联的。

函数签名中的生命周期注解

要在函数签名中使用生命周期注释，我们需要在函数名和参数列表之间的尖括号内声明泛型生命周期参数，就像我们对泛型类型参数所做的那样。

我们希望签名表达以下约束：只要两个参数都有效，返回的引用就有效。这是参数的生存期和返回值之间的关系。我们将生命周期命名为 a，然后将其添加到每个引用中。

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

在函数中注释生命周期时，注释放在函数签名中，而不是函数体中。生命周期注释成为函数契约的一部分，就像签名中的类型一样。

让函数签名包含生命周期契约意味着 Rust 编译器所做的分析可以更简单。如果函数的注释方式或调用方式有问题，编译器错误可以更精确地指向我们的代码部分和约束。相反，如果 Rust 编译器对我们想要的生命周期关系做出更多推断，那么编译器可能只能指出代码的使用与问题的原因有许多步之隔。

请记住，当我们在这个函数签名中指定生命周期参数时，我们不会改变传入或返回的任何值的生命周期。相反，我们指定借用检查器应该拒绝不遵守这些约束的任何值。请注意，longest 函数不需要确切地知道 x 和 y 将存在多长时间，只需要某些作用域可以替换 'a 以满足此签名。

longest 函数的签名向我们保证：参数中的 x 和 y、返回值 str 的生命周期至少与生命周期 'a 一样长。

示例 1：

fn main() {
    let string1 = String::from("long string is long");
    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {result}");
    }
}

在本例中，string1 在外部作用域结束之前都是有效的，string2、result 在内部作用域结束之前都是有效的。编译通过。

示例 2：

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
    }
    println!("The longest string is {result}");
}

编译报错：

编译器规定 string2 必须在外部作用域结束之前有效。我们使用相同的生命周期形参 'a 注释了函数参数和返回值的生命周期，这就告诉 Rust：longest 函数返回的引用的生命周期与传入的引用的生命周期中较小的那个相同。

从生命周期的角度思考

指定生命周期参数的方式取决于函数正在做什么。

例如，如果 longest 函数始终返回第一个参数，则不需要在 y 形参上指定生命周期，因为 y 的生命周期与 x 或返回值的生命周期没有任何关系。

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

当从函数返回引用时，返回类型的生命周期参数需要与其中一个参数的生命周期参数匹配。因为如果返回的引用不指向其中一个形参，则必须指向在此函数中创建的值。然而，这将是一个悬空引用。

fn longest<'a>(x: &str, y: &str) -> &'a str {
    let result = String::from("really long string");
    result.as_str()
}

这个实现无法编译，因为即使我们为返回类型指定了一个生命周期参数 'a，返回值的生命周期与参数的生命周期根本无关。我们无法指定改变悬空引用的生命周期参数，Rust 也不允许我们创建悬空引用。

一句话概括，生命周期语法是为了连接函数的各种参数和返回值的生命周期。一旦它们连接起来，Rust 就有足够的信息来允许内存安全的操作，并禁止可能创建悬空指针或违反内存安全的操作。

结构定义中的生命周期注解

结构体可以保存引用，但在这种情况下，我们需要在结构定义中的每个引用上添加一个生命周期注释。

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

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

这个结构体有一个字段 part，它保存一个字符串切片，这是一个引用。与泛型数据类型一样，在结构体名称后面的尖括号内声明泛型生命周期形参的名称，以便可以在结构体定义的主体中使用该生命周期形参。这个注释意味着 ImportantExcerpt 的实例不能比它在 part 字段中保存的引用的生命周期更长。

这里的 main 函数创建了一个 ImportantExcerpt 结构体的实例，该结构体包含对变量 novel 所拥有的 String 的第一个句子的引用。novel 中的数据在 ImportantExcerpt 实例创建之前就已经存在。此外， novel 直到 ImportantExcerpt 退出作用域后才会退出作用域，因此 ImportantExcerpt 实例中的引用是有效的。

省略生命周期

由前文得知，每个引用都有生命周期，并且需要为使用引用的函数或结构指定生命周期参数。

但凡是都有例外，看这个例子：

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[..]
}

在早期版本（1.0 之前）的 Rust 中，这段代码无法编译，因为每个引用都需要显式的生命周期。必须写成这样：

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

在编写了大量 Rust 代码之后，Rust 团队发现 Rust 程序员在特定情况下会一次又一次地输入相同的生命周期注释。这些情况是可以预测的，并遵循一些确定的模式。于是，开发人员将这些模式编程到编译器的代码中，这样借用检查器就可以推断出这些情况下的生存期，而不需要显式注释。

这叫做生命周期省略规则。这些不是程序员要遵循的规则，而是编译器将考虑的一组特殊情况。如果代码符合这些情况，则不需要显式地编写生命周期。

省略规则不提供完整的推理。如果在 Rust 应用这些规则之后，引用的生存期仍然存在歧义，编译器将不会猜测剩余引用的生存期应该是什么，而是直接报错。

函数或方法参数的生命周期称为输入生命周期，返回值的生命周期称为输出生命周期。

当没有显式注释时，编译器使用 3 条规则来计算引用的生命周期。第一条规则适用于输入生命周期，第二条和第三条规则适用于输出生命周期。如果编译器到达这三条规则的末尾，并且仍然有无法计算出生存期的引用，编译器将停止并报错。这些规则适用于 fn 定义和 impl 块。

• 规则一：编译器为每个引用形参分配一个生命周期形参。
• 规则二：如果只有一个输入生命周期参数，则将该生命周期赋给所有输出生命周期参数。
• 规则三：如果有多个输入生命周期参数，但其中一个是 &self 或 &mut self，self 的生命周期被分配给所有的输出生命周期参数。

我们尝试扮演编译器，应用这些规则来计算下列 first_word 函数签名中引用的生命周期。

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

应用规则一，指定每个参数都有自己的生命周期，按惯例用 'a 表示：

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

应用规则二，因为只有一个输入生命周期，则指定将输入参数的生命周期分配给输出生命周期：

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

现在，这个函数签名中的所有引用都有生命周期，通过了。

让我们看另一个例子：

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

应用规则一，指定每个参数都有自己的生命周期：

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

规则二不适用，因为存在多个输入生命周期。规则三也不适用，因为 longest 是一个函数而不是一个方法，所以没有一个参数是 self。在研究了这三条规则之后，我们仍然没有弄清楚返回类型的生命周期是多少。这就是编译出错的原因：编译器遍历了生命周期省略规则，但仍然无法计算出签名中引用的所有生命周期。

方法定义中的生命周期注释

在具有生命周期的结构体上实现方法时，使用与泛型类型参数相同的语法，如清单10-11所示。在哪里声明和使用生命周期参数取决于它们是否与结构体字段或方法参数和返回值相关。

结构字段的生命周期名称总是需要在 impl 关键字之后声明，然后在结构名之后使用，因为这些生命周期是结构类型的一部分。

在 impl 块内的方法签名中，引用可能与结构体字段中引用的生命周期相关联，或者它们可能是独立的。此外，生命周期省略规则通常使得方法签名中不需要生命周期注释。

以 ImportantExcerpt 结构体为例，首先，我们将使用一个名为 level 的方法，其唯一的参数是对 self 的引用，其返回值是 i32，而 i32 不是对任何东西的引用。

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

必须在 impl 之后声明生命周期参数，并在类型名之后使用它，但我们不需要注释对 self 引用的生命周期。

下面是应用规则三的示例：

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {announcement}");
        self.part
    }
}

有两个输入生命周期，因此 Rust 应用规则一给 &self 和 announcement 分别指定生命周期。然后，因为其中一个参数是 &self，应用规则三，返回类型获得 &self 的生命周期。至此，方法参数、返回值都拥有了生命周期，编译通过。

静态生命周期

我们需要讨论的一个特殊生命周期------静态生命周期，它表示受影响的引用可以在程序的整个持续时间内存在。

我们可以这样注释：

let s: &'static str = "I have a static lifetime.";

该字符串的文本直接存储在程序的二进制文件中，该文件总是可用的。因此，所有字符串字面值都有静态生命周期。

泛型类型参数、trait 约束和生命周期

以最后一个大一统的例子收尾：

use std::fmt::Display;

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

longest_with_an_announcement 函数有一个名为 ann 的泛型类型 T 的参数，它可以由任何实现 where 子句指定的 Display trait 的类型填充。

函数主体中，ann 参数将使用 {} 打印，这就是为什么需要绑定 Display trait 的原因。

因为生命周期是泛型类型，所以生命周期参数 'a 和泛型类型参数 T 的声明位于函数名后面尖括号内的同一列表中。