Rust 生命周期实战:从作用域与借用检查到 Elision 消除规则(Rust By Practice 练习指南)

原创2026-09-21 16:07:432,195 阅读
文章标签:文档教程教育

Rust 生命周期实战:从作用域与借用检查到 Elision 消除规则(Rust By Practice 练习指南)

生命周期(Lifetime)是 Rust 借用检查器(Borrow Checker)判断"引用是否合法"的核心机制:编译器通过它确保所有借用都不会悬空,即引用指向的数据在引用被使用期间一定仍然存活。本篇文章以 Rust By Practice(Rust 语言实战) 中"生命周期基础"一章为骨架,逐题讲解生命周期的范围、显式标注(函数、结构体、方法)、生命周期消除规则(Elision)等核心概念,并结合 参考答案 给出每种错误的标准修法。读完本文,你将能看懂并亲手写出正确的生命周期标注,理解为什么 longest 这类函数必须让返回引用的生命周期与参数一致,也能熟练利用消除规则写出更简洁的 Rust 代码。

生命周期是什么:编译器眼中的"引用合法性"

Rust 通过生命周期来确保所有的借用都是合法的。典型的,一个变量在创建时生命周期随之开始,销毁时生命周期也随之结束:

fn main() {
    let i = 3;
    {
        let borrow1 = &i; // `borrow1` 生命周期开始. ──┐
        println!("borrow1: {}", borrow1); //              │
    } // `borrow1` 生命周期结束. ───────────────────────┘
    {
        let borrow2 = &i;
        println!("borrow2: {}", borrow2);
    }
}

Rust 中的每个引用都有一个生命周期,即该引用被保证有效的代码区域。借用检查器会在编译期验证:引用不能活得比它指向的数据更久。这与所有权机制一脉相承——你可以先阅读 引用和借用 一章巩固基础,再进入本节的练习。

生命周期的范围:作用域决定一切

🌟 练习 1:嵌套作用域中的生命周期

题目要求为 i 和 borrow2 标注合适的生命周期范围。关键观察点如下:

  • i 拥有最长的生命周期,因为它的作用域完整地包含了 borrow1 和 borrow2;
  • borrow1 和 borrow2 的生命周期并无关联,因为它们的作用域没有重叠。

参考解答(见 solutions/lifetime/basic.md 练习 1)把三个生命周期画成三段独立的"括号",一目了然:

fn main() {
    let i = 3; // Lifetime for `i` starts. ────────────────┐
    { //                                                   │
        let borrow1 = &i; // `borrow1` lifetime starts. ──┐│
        println!("borrow1: {}", borrow1); //              ││
    } // `borrow1` ends. ─────────────────────────────────┘│
    { //                                                   │
        let borrow2 = &i; // `borrow2` lifetime starts. ──┐│
        println!("borrow2: {}", borrow2); //              ││
    } // `borrow2` ends. ─────────────────────────────────┘│
}   // Lifetime ends. ─────────────────────────────────────┘

结论:生命周期由作用域界定,i 的生命周期完全覆盖了两个借用;两个借用互不重叠、互不干扰。

🌟🌟 练习 2:引用不能活得比数据久

题目给出的示例是最经典的悬垂引用(dangling reference)模型:

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

在这个示例中,r 的生命周期 'a 完全被 x 的生命周期 'b 包含,借用合法。而题目要我们修改的代码则相反:

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

这里 r 的生命周期 'a 明显长于 x 的生命周期 'b:在 x 于内层块结束时被销毁后,r 还要在 println! 中被使用。我们不能借用生命周期更小的数据——这段代码无法通过编译,正是借用检查器在发挥作用。

生命周期标注:手动告诉编译器"谁比谁活得久"

Rust 的借用检查器使用显式的生命周期标注来确定一个引用的合法范围。但在大多数场景下,我们无需手动标注生命周期,因为编译器会在某些情况下自动应用生命周期消除规则(见后文)。不过在了解消除规则之前,我们仍需要先学会如何手动标记。

生命周期标注的语法是撇号加小写字母(习惯上用 'a、'b、'c…),例如 &'a i32 表示"一个生命周期为 'a 的 i32 引用"。

函数中的生命周期

先忽略生命周期消除规则,函数签名中的生命周期有以下限制:

  • 需要为每个引用标注上合适的生命周期;
  • 返回值中的引用,它的生命周期要么跟某个引用参数相同,要么是 'static。

看一个完整的示例(原文档"函数"小节):

// 引用参数中的生命周期 'a 至少要跟函数活得一样久
fn print_one<'a>(x: &'a i32) {
    println!("`print_one`: x is {}", x);
}

// 可变引用依然需要标注生命周期
fn add_one<'a>(x: &'a mut i32) {
    *x += 1;
}

// 每个参数都拥有自己独立的生命周期;这个例子足够简单,它们应该被标记上相同的生命周期 'a,
// 但对于复杂的例子而言,独立的生命周期标注是可能存在的
fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("`print_multi`: x is {}, y is {}", x, y);
}

// 返回一个通过参数传入的引用是很常见的,这种情况下需要标注上正确的生命周期
fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x }

fn main() {
    let x = 7;
    let y = 9;

    print_one(&x);
    print_multi(&x, &y);

    let z = pass_x(&x, &y);
    print_one(z);

    let mut t = 3;
    add_one(&mut t);
    print_one(&t);
}

要点总结:

  • <'a> 声明在函数名之后,是生命周期参数的"定义";
  • 每个引用参数都可以绑定独立的生命周期(如 'a、'b),它们之间互不约束;
  • 返回的引用必须来自某个输入引用——返回值的生命周期必须与某个参数的生命周期相同,这保证了调用者拿到的引用必然指向调用者仍拥有的数据。

🌟 练习 3:为 longest 添加生命周期标注

/* 添加合适的生命周期标注,让下面的代码工作 */
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {}

longest 返回 x 或 y 之一,编译器无法自动推断返回引用到底属于哪个参数,因此必须显式标注。参考解答(solutions/lifetime/basic.md 练习 3):

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

fn main() {}

这里两个参数使用同一个生命周期 'a,含义是:x、y 与返回值共享同一个生命周期约束,即"返回值活得跟 x 和 y 中较短的那个一样长"。这是《Rust 程序设计语言》中经典的 longest 示例在实战中的标准写法。

🌟🌟🌟 练习 4:三种方式修复 invalid_output

/* 使用三种方法修复下面的错误  */
fn invalid_output<'a>() -> &'a String {
    &String::from("foo")
}

fn main() {}

这段代码的错误在于:String::from("foo") 是一个函数内部创建的临时值,它在函数返回时就被销毁,而返回值却声称拥有 'a 的生命周期——返回了一个指向已释放内存的悬垂引用。参考解答(练习 4)给出了三种修复思路:

方案一:直接返回拥有所有权的 String,去掉引用

fn invalid_output() -> String {
    String::from("foo")
}

fn main() {}

方案二:返回 'static 字符串字面量

fn invalid_output() -> &'static str {
    "foo"
}

fn main() {}

字符串字面量被直接编译进二进制文件,生命周期为 'static,因此可以安全返回。

方案三:让返回值来自参数

fn invalid_output<'a>(s: &'a String) -> &'a String {
    s
}

fn main() {}

把引用"寄生于"调用者传入的参数上,返回值与参数共享生命周期 'a。

🌟🌟 练习 5:不能把小的生命周期强转成大的

// `print_refs` 有两个引用参数,它们的生命周期 `'a` 和 `'b` 至少得跟函数活得一样久
fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("x is {} and y is {}", x, y);
}

/* 让下面的代码工作 */
fn failed_borrow<'a>() {
    let _x = 12;

    // ERROR: `_x` 活得不够久
    let y: &'a i32 = &_x;
}

fn main() {
    let (four, nine) = (4, 9);

    print_refs(&four, &nine);
    // 这里,four 和 nine 的生命周期必须要比函数 print_refs 长

    failed_borrow();
    // `failed_borrow` 没有传入任何引用去限制生命周期 `'a`,因此此时的 `'a` 生命周期是没有任何限制的,它默认是 `'static`
}

failed_borrow 没有接收任何引用参数,因此 'a 没有任何约束,默认退化为 'static;而局部变量 _x 的生命周期显然远小于 'static,&_x 无法满足 &'a i32。不能将一个小的生命周期强转成大的。参考解答(练习 5)干脆不再用 'a 绑定局部引用:

fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("x is {} and y is {}", x, y);
}

/* Make it work */
fn failed_borrow<'a>() {
    let _x = 12;
    let y: &i32 = &_x; // 让编译器自己推断局部引用的生命周期
}

fn main() {
    let (four, nine) = (4, 9);

    print_refs(&four, &nine);

    failed_borrow();
}

结构体中的生命周期

结构体可以保存引用,但结构体本身是"值",它必须保证:结构体存活期间,其字段引用的数据也必须存活。因此保存引用的结构体必须声明生命周期参数,语法为 struct Foo<'a> { field: &'a T }。

🌟 练习 6:为结构体与枚举添加生命周期

/* 增加合适的生命周期标注,令代码正常工作 */

// `i32` 的引用必须比 `Borrowed` 活得更久
#[derive(Debug)]
struct Borrowed(&i32);

// 类似的,下面两个引用也必须比结构体 `NamedBorrowed` 活得更久
#[derive(Debug)]
struct NamedBorrowed {
    x: &i32,
    y: &i32,
}

#[derive(Debug)]
enum Either {
    Num(i32),
    Ref(&i32),
}

fn main() {
    let x = 18;
    let y = 15;

    let single = Borrowed(&x);
    let double = NamedBorrowed { x: &x, y: &y };
    let reference = Either::Ref(&x);
    let number    = Either::Num(y);

    println!("x is borrowed in {:?}", single);
    println!("x and y are borrowed in {:?}", double);
    println!("x is borrowed in {:?}", reference);
    println!("y is *not* borrowed in {:?}", number);
}

参考解答(练习 6)为每个含引用的类型都引入生命周期参数:

// 类型 `Borrowed` 持有一个指向 `i32` 的引用,该引用必须活得比 `Borrowed` 久
#[derive(Debug)]
struct Borrowed<'a>(&'a i32);

// 两个引用都必须活得比结构体久
#[derive(Debug)]
struct NamedBorrowed<'a> {
    x: &'a i32,
    y: &'a i32,
}

// 枚举要么持有 `i32`,要么持有对 `i32` 的引用
#[derive(Debug)]
enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

fn main() {
    let x = 18;
    let y = 15;

    let single = Borrowed(&x);
    let double = NamedBorrowed { x: &x, y: &y };
    let reference = Either::Ref(&x);
    let number    = Either::Num(y);

    println!("x is borrowed in {:?}", single);
    println!("x and y are borrowed in {:?}", double);
    println!("x is borrowed in {:?}", reference);
    println!("y is *not* borrowed in {:?}", number);
}

注意 Either::Num(y) 是按值持有 i32,不涉及引用,因此不需要生命周期——这与 Either::Ref(&x) 形成鲜明对比。

🌟🌟 练习 7:两个独立生命周期与作用域

/* 让代码工作 */

#[derive(Debug)]
struct NoCopyType {}

#[derive(Debug)]
struct Example<'a, 'b> {
    a: &'a u32,
    b: &'b NoCopyType
}

fn main()
{
  let var_a = 35;
  let example: Example;

  {
    let var_b = NoCopyType {};

    /* 修复错误 */
    example = Example { a: &var_a, b: &var_b };
  }

  println!("(Success!) {:?}", example);
}

编译错误的原因:var_b 定义在内层块中,example.b 引用 var_b 的生命周期 'b 被限制在内层块内,而 example 在内层块结束后还要被 println! 使用。参考解答(练习 7)的修法很直观——把内层块删除,让 var_b 与 example 处于同一作用域:

#[derive(Debug)]
struct NoCopyType {}

#[derive(Debug)]
struct Example<'a, 'b> {
    a: &'a u32,
    b: &'b NoCopyType
}

fn main()
{
  /* 'a 绑定到 main 的栈帧 */
  let var_a = 35;
  let example: Example;

  /* 生命周期 'b 绑定到当前作用域 */
  let var_b = NoCopyType {};

  example = Example { a: &var_a, b: &var_b };

  println!("(Success!) {:?}", example);
}

从源码注释可以看出,'a 绑定在 main 栈帧上,'b 绑定在变量所处的作用域上——当 var_b 移出内层块后,'b 与 'a 一样长,引用自然合法。

🌟🌟 练习 8:修复函数签名中缺失的生命周期

#[derive(Debug)]
struct NoCopyType {}

#[derive(Debug)]
#[allow(dead_code)]
struct Example<'a, 'b> {
    a: &'a u32,
    b: &'b NoCopyType
}

/* 修复函数的签名 */
fn fix_me(foo: &Example) -> &NoCopyType
{ foo.b }

fn main()
{
    let no_copy = NoCopyType {};
    let example = Example { a: &1, b: &no_copy };
    fix_me(&example);
    println!("Success!")
}

fix_me 返回 foo.b,即一个类型为 &'b NoCopyType 的引用,因此函数签名必须显式写出 'b。参考解答(练习 8)用 '_ 省略掉 foo 中不相关的 'a:

#[derive(Debug)]
struct NoCopyType {}

#[derive(Debug)]
#[allow(dead_code)]
struct Example<'a, 'b> {
    a: &'a u32,
    b: &'b NoCopyType
}

/* 修复函数签名 */
fn fix_me<'b>(foo: &Example<'_, 'b>) -> &'b NoCopyType
{ foo.b }

fn main()
{
    let no_copy = NoCopyType {};
    let example = Example { a: &1, b: &no_copy };
    fix_me(&example);
    println!("Success!")
}

注意这里的 '_(匿名生命周期)告诉编译器"这个位置的参数生命周期由编译器推断",而返回值的生命周期 'b 则必须与 foo.b 一致。

方法中的生命周期标注

方法的生命周期标注跟函数类似,但有一个关键差异:impl 块也需要携带生命周期参数(如果方法签名或结构体用到的话)。

示例(原文档"方法"小节):

struct Owner(i32);

impl Owner {
    fn add_one<'a>(&'a mut self) { self.0 += 1; }
    fn print<'a>(&'a self) {
        println!("`print`: {}", self.0);
    }
}

fn main() {
    let mut owner = Owner(18);

    owner.add_one();
    owner.print();
}

self 本身就是引用,因此同样需要标注生命周期:可变方法 add_one 接收 &'a mut self,只读方法 print 接收 &'a self。

🌟🌟 练习 9:为 impl 块添加生命周期

/* 添加合适的生命周期让下面代码工作 */
struct ImportantExcerpt {
    part: &str,
}

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

fn main() {}

结构体字段 part: &str 是引用,结构体必须携带生命周期;impl 块也要随之携带。参考解答(练习 9):

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

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

fn main() {}

从本仓库的 深入生命周期 一章还可以看到,impl 块的生命周期参数甚至可以不写进方法里——只要结构体声明了 'a,impl 块按 impl<'a> Foo<'a> 写即可(更多省略规则见 advance.md 中的"更多省略规则"小节,其中展示了 BufReader<'a> 在 impl 中可省略为 BufReader<'_>)。

生命周期消除(Elision):编译器替你标注

有一些生命周期的标注方式非常常见,因此编译器提供了一些规则,可以在一些场景下无需标注生命周期,既节省了敲击键盘的繁琐,又能提升可读性。这种规则被称为生命周期消除规则(Elision)。

需要强调的是:消除规则之所以存在,仅仅是因为这些场景太通用了、为了方便用户而已。对于借用检查器而言,该有的生命周期一个都不能少,只不过对于用户而言可以省去一些标注。Rust 编译器内置的三条消除规则(从 Rust Reference 可知)大致是:

  1. 每个引用参数都被赋予一个独立的生命周期参数;
  2. 如果只有一个输入生命周期参数,那么它被赋予所有输出(返回值)生命周期参数;
  3. 如果有多个输入生命周期参数,但其中一个是 &self 或 &mut self,那么 self 的生命周期被赋予所有输出生命周期参数。

正是规则 2 让我们无需为 fn first_word(s: &str) -> &str 这类单参数函数手写生命周期;也正是规则 2 的缺失,让 longest(x: &str, y: &str) -> &str(两个输入参数)必须手动标注。

🌟🌟 练习 10:移除所有可以消除的生命周期标注

/* 移除所有可以消除的生命周期标注 */

fn nput<'a>(x: &'a i32) {
    println!("`annotated_input`: {}", x);
}

fn pass<'a>(x: &'a i32) -> &'a i32 { x }

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

struct Owner(i32);

impl Owner {
    fn add_one<'a>(&'a mut self) { self.0 += 1; }
    fn print<'a>(&'a self) {
        println!("`print`: {}", self.0);
    }
}

struct Person<'a> {
    age: u8,
    name: &'a str,
}

enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

fn main() {}

参考解答(练习 10)删掉了所有编译器能自行推导的标注:

// 单引用参数:无返回值引用,生命周期可直接省略
fn nput(x: &i32) {
    println!("`annotated_input`: {}", x);
}

// 单输入生命周期参数:自动赋给返回值(消除规则 2)
fn pass(x: &i32) -> &i32 { x }

// 两个输入生命周期参数:返回引用必须手动指定,这里显式返回 x 的 'a
fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    x
}

struct Owner(i32);

impl Owner {
    // 方法中 &mut self / &self 的生命周期同样可消除(消除规则 3)
    fn add_one(&mut self) { self.0 += 1; }
    fn print(&self) {
        println!("`print`: {}", self.0);
    }
}

struct Person<'a> {
    age: u8,
    name: &'a str,
}

enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

fn main() {}

值得注意的细节:

  • fn pass(x: &i32) -> &i32 之所以能省略,是因为它只有一个输入引用参数,消除规则 2 会自动把 x 的生命周期赋给返回值;
  • fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str 有两个输入参数,编译器无法自动决定返回值的生命周期,因此这个标注不能消除;
  • Person 和 Either 中保存引用的字段同样不能省略——生命周期标注对字段引用是强制的。

练习环境与运行方式

本文所有练习均来自 Rust By Practice 中文版(zh-CN 目录)的 生命周期基础,每道题的答案统一存放在 solutions/lifetime/basic.md。仓库使用 mdbook)开启了 output.html.playpen.editable = true,因此所有带 rust,editable 标记的代码块都可以在网页上直接编辑并运行。

如果你希望在本地运行这些练习(详见 zh-CN/src/why-exercise.md):

$ cargo install mdbook
$ cd rust-by-practice && mdbook serve zh-CN/

在本地 Windows 或 Linux 服务器上运行时,建议用 -n 指定监听 IP、-p 指定端口(不指定则默认 3000):

$ mdbook serve -p 8888 -n 127.0.0.1 zh-CN/

小结

通过本节的 10 道练习,我们完整覆盖了 Rust 生命周期最核心的基础知识:

知识点 核心结论
生命周期范围 引用不能活得比其指向的数据更久;生命周期由作用域界定
函数标注 每个引用参数都需要生命周期;返回引用的生命周期必须等于某个参数或为 'static
结构体/枚举/方法 保存引用的类型必须声明生命周期参数;impl 块同步携带
消除规则 单输入参数、&self 方法的标注可自动推导;多参数函数的返回引用必须手动标注

理解这些基础后,可以继续阅读 &'static 和 T: 'static('static 生命周期与特征约束)、深入生命周期(生命周期约束、HRTB、NLL 非词法生命周期、再借用等进阶主题),以及仓库中更完整的 英文版对应章节 进行对照学习。

登录后查看全文
rust-by-practice