Rust 程序设计语言

fn main() {
    let r;

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

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

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

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

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

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

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

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

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}");
}

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

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}");
    }
}

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

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}");
}

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

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

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

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

我们为参数 x 和返回类型指定了生命周期参数 'a，但没有为参数 y 指定，因为 y 的生命周期与 x 的生命周期或返回值都没有关系。

函数返回引用时，返回类型的生命周期参数必须与某个参数的生命周期参数匹配。如果返回的引用并非指向某个参数，它就必须指向函数内部创建的值。然而，这会形成悬垂引用，因为该值会在函数结束时离开作用域。请看下面这个无法编译的 longest 函数实现尝试：

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

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

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

这里，尽管我们为返回类型指定了生命周期参数 'a，这个实现仍然无法编译，因为返回值的生命周期与参数的生命周期毫无关系。错误信息如下：

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0515]: cannot return value referencing local variable `result`
  --> src/main.rs:11:5
   |
11 |     result.as_str()
   |     ------^^^^^^^^^
   |     |
   |     returns a value referencing data owned by the current function
   |     `result` is borrowed here

For more information about this error, try `rustc --explain E0515`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

问题在于，result 会在 longest 函数结束时离开作用域并被清理，而我们却试图从函数中返回对 result 的引用。无论怎样指定生命周期参数，都无法改变这个悬垂引用；Rust 也不会允许我们创建悬垂引用。在这种情况下，最好返回拥有所有权的数据类型而不是引用，这样调用函数就负责清理该值。

归根结底，生命周期语法用于连接函数各参数与返回值的生命周期。建立这些关系后，Rust 就掌握了足够的信息，可以允许内存安全的操作，并禁止会产生悬垂指针或以其他方式破坏内存安全的操作。

在结构体定义中

到目前为止，我们定义的结构体都保存拥有所有权的类型。我们也可以定义保存引用的结构体，但这时必须为结构体定义中的每个引用添加生命周期标注。清单 10-24 定义了一个名为 ImportantExcerpt、用于保存字符串切片的结构体。

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 离开作用域之后才会离开作用域，因此该实例中的引用有效。

生命周期省略

你已经了解到每个引用都有生命周期，并且使用引用的函数或结构体需要指定生命周期参数。不过，我们在清单 4-9 中定义过一个函数，这里在清单 10-25 中再次展示，它没有生命周期标注也能编译。

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

fn main() {
    let my_string = String::from("hello world");

    // first_word works on slices of `String`s
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word works on slices of string literals
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

这个函数无需生命周期标注也能编译，原因与 Rust 的历史有关：在早期（1.0 之前）的 Rust 版本中，这段代码无法编译，因为每个引用都需要显式生命周期。当时，函数签名必须这样写：

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

编写了大量 Rust 代码后，Rust 团队发现程序员在某些情况下会反复填写相同的生命周期标注。这些情况可以预测，并遵循少数确定的模式。开发者将这些模式编入编译器，使借用检查器能够在这些情况下推断生命周期，而不再需要显式标注。

这段 Rust 历史值得一提，因为未来可能会发现更多确定的模式并将其加入编译器。将来需要的生命周期标注或许会更少。

编入 Rust 引用分析过程的这些模式称为生命周期省略规则。它们不是要求程序员遵守的规则，而是编译器会考虑的一组特定情形；如果代码符合这些情形，就无需显式写出生命周期。

省略规则并不能提供完整的推断。如果 Rust 应用这些规则后，引用的生命周期仍有歧义，编译器就不会猜测剩余引用的生命周期。它会报告错误，你可以通过添加生命周期标注来解决。

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

没有显式标注时，编译器会使用三条规则确定引用的生命周期。第一条规则适用于输入生命周期，第二和第三条规则适用于输出生命周期。如果编译器应用完这三条规则后，仍有引用的生命周期无法确定，就会停止并报告错误。这些规则既适用于 fn 定义，也适用于 impl 块。

第一条规则是：编译器为每个引用类型的参数分配一个生命周期参数。换句话说，只有一个参数的函数会得到一个生命周期参数：fn foo<'a>(x: &'a i32)；有两个参数的函数会得到两个独立的生命周期参数：fn foo<'a, 'b>(x: &'a i32, y: &'b i32)，以此类推。

第二条规则是：如果恰好只有一个输入生命周期参数，就将该生命周期分配给所有输出生命周期参数：fn foo<'a>(x: &'a i32) -> &'a i32。

第三条规则是：如果有多个输入生命周期参数，但其中一个是 &self 或 &mut self（因为这是一个方法），就将 self 的生命周期分配给所有输出生命周期参数。第三条规则减少了所需符号，因此让方法更易阅读和编写。

现在假设我们是编译器，来应用这些规则，确定清单 10-25 中 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 {

现在，这个函数签名中的所有引用都有了生命周期，编译器可以继续分析，而不需要程序员在签名中显式标注生命周期。

再看另一个例子，这次使用我们在清单 10-20 中开始讨论的 longest 函数；当时它还没有生命周期参数：

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

应用第一条规则：每个参数都有自己的生命周期。这次有两个参数，因此会得到两个生命周期：

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

可以看到，第二条规则不适用，因为输入生命周期不止一个。第三条规则也不适用，因为 longest 是函数而不是方法，所以没有参数是 self。应用完三条规则后，我们仍然无法确定返回类型的生命周期。这就是尝试编译清单 10-20 中的代码时会报错的原因：编译器应用了生命周期省略规则，但仍然无法确定签名中所有引用的生命周期。

由于第三条规则实际上只适用于方法签名，接下来我们会在方法的上下文中查看生命周期，以了解为何通常不必在方法签名中标注生命周期。

在方法定义中

为带有生命周期的结构体实现方法时，我们使用与泛型类型参数相同的语法，如清单 10-11 所示。生命周期参数的声明和使用位置，取决于它们关联的是结构体字段，还是方法参数与返回值。

结构体字段的生命周期名称必须在 impl 关键字后声明，并在结构体名称后使用，因为这些生命周期属于结构体类型的一部分。

在 impl 块内的方法签名中，引用可能与结构体字段中引用的生命周期相关，也可能彼此独立。此外，生命周期省略规则通常使方法签名无需生命周期标注。下面使用清单 10-24 中定义的 ImportantExcerpt 结构体来看几个例子。

首先，我们使用名为 level 的方法。它唯一的参数是对 self 的引用，返回值是一个 i32，并非任何内容的引用：

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

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

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

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,
    };
}

必须在 impl 后声明生命周期参数，并在类型名称后使用它。不过，由于第一条省略规则，我们无需为 self 的引用标注生命周期。

下面的例子适用第三条生命周期省略规则：

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

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

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

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,
    };
}

这里有两个输入生命周期，因此 Rust 应用第一条生命周期省略规则，分别为 &self 和 announcement 分配生命周期。接着，由于其中一个参数是 &self，返回类型就获得 &self 的生命周期；至此，所有生命周期都已确定。

'static 生命周期

还需要讨论一种特殊生命周期 'static，它表示相关引用可以在整个程序运行期间都有效。所有字符串字面量都具有 'static 生命周期，可以像下面这样标注：

#![allow(unused)]
fn main() {
let s: &'static str = "I have a static lifetime.";
}

这个字符串的文本直接存储在程序的二进制文件中，因此始终可用。所以所有字符串字面量的生命周期都是 'static。

你可能会在错误信息中看到使用 'static 生命周期的建议。但在将 'static 指定为某个引用的生命周期之前，先想一想该引用是否真的会在整个程序运行期间都有效，以及你是否希望它如此。大多数时候，错误信息建议使用 'static，是因为代码试图创建悬垂引用，或可用生命周期之间不匹配。在这些情况下，正确的做法是修复问题，而不是指定 'static 生命周期。

泛型类型参数、Trait 约束与生命周期

最后简要看看如何在同一个函数中同时指定泛型类型参数、trait 约束和生命周期！

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

    let result = longest_with_an_announcement(
        string1.as_str(),
        string2,
        "Today is someone's birthday!",
    );
    println!("The longest string is {result}");
}

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 }
}

这是清单 10-21 中的 longest 函数，它会返回两个字符串切片中较长的一个。现在它多了一个名为 ann、类型为泛型 T 的参数。根据 where 子句，T 可以是任何实现了 Display trait 的类型。这个额外参数会通过 {} 打印，因此需要 Display trait 约束。由于生命周期也是一种泛型，生命周期参数 'a 与泛型类型参数 T 的声明会放在函数名后的同一个尖括号列表中。

总结

本章涵盖了很多内容！现在你已经了解泛型类型参数、trait 与 trait 约束，以及泛型生命周期参数，可以开始编写适用于多种情况且没有重复代码的程序了。泛型类型参数让代码可以应用于不同类型；trait 和 trait 约束确保这些泛型类型具有代码所需的行为。你还学会了如何使用生命周期标注，确保灵活的代码不会包含悬垂引用。所有这些分析都在编译时进行，不会影响运行时性能！

信不信由你，本章讨论的主题还有更多内容：第 18 章会介绍 trait 对象，这是使用 trait 的另一种方式。生命周期标注还有一些更复杂的场景，只有在非常进阶的情况下才需要；对此可以阅读Rust 参考。接下来，你将学习如何在 Rust 中编写测试，以确保代码按预期工作。