Rust 生命周期实战:从作用域与借用检查到 Elision 消除规则(Rust By Practice 练习指南)
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 可知)大致是:
- 每个引用参数都被赋予一个独立的生命周期参数;
- 如果只有一个输入生命周期参数,那么它被赋予所有输出(返回值)生命周期参数;
- 如果有多个输入生命周期参数,但其中一个是
&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 非词法生命周期、再借用等进阶主题),以及仓库中更完整的 英文版对应章节 进行对照学习。