3 生命周期 on 编程那些事儿

3.1 借用与函数

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/simple-borrows.html

3.1 借用与函数

作为借用检查的一部分，编译器需要推理借用如何流入与流出函数。最简单的情况下，借用持续整个函数调用期间：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn borrows(x: &i32) {
 dbg!(x);
}

fn main() {
 let mut val = 123;

 // 为函数调用借用 `val`。
 borrows(&val);

 // 借用已结束，我们可以自由地修改。
 val += 5;
}

本例中我们为调用 borrows 而借用 val。这会限制我们修改 val 的能力，但一旦函数调用返回，借用就结束了，我们又可以自由修改。

3.2 返回借用

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/returning-borrows.html

3.2 返回借用

但函数也可以返回引用！这意味着借用会从函数中流回：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn identity(x: &i32) -> &i32 {
 x
}

fn main() {
 let mut x = 123;

 let out = identity(&x);

 // x = 5; // 🛠️❌ `x` 仍被借用！

 dbg!(out);
}

Rust 函数可以返回引用，意味着借用可以从函数中流回。

3.3 多个借用

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/multiple-borrows.html

3.3 多个借用

但当多个借用传入函数、且有一个要返回时呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn multiple(a: &i32, b: &i32) -> &i32 {
 todo!("Return either `a` or `b`")
}

fn main() {
 let mut a = 5;
 let mut b = 10;

 let r = multiple(&a, &b);

 // Which one is still borrowed?
 // Should either mutation be allowed?
 a += 7;
 b += 7;

 dbg!(r);
}

这段代码目前无法编译，因为缺少生命周期标注。在让它编译之前，借此机会让学员思考：返回值应延长哪个参数借用。

3.4 同时借用两者

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/borrow-both.html

3.4 同时借用两者

本例中，函数可能返回 a 或 b。我们用生命周期标注告诉编译器：两个借用都可能流入返回值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn pick<'a>(c: bool, a: &'a i32, b: &'a i32) -> &'a i32 {
 if c { a } else { b }
}

fn main() {
 let mut a = 5;
 let mut b = 10;

 let r = pick(true, &a, &b);

 // Which one is still borrowed?
 // Should either mutation be allowed?
 // a += 7;
 // b += 7;

 dbg!(r);
}

pick 函数会根据 c 的值返回 a 或 b，这意味着我们在编译期无法知道会返回哪一个。

3.5 只借用其中一个

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/borrow-one.html

3.5 只借用其中一个

本例中 find_nearest 接受多个借用，但只返回其中一个。生命周期标注显式地把返回的借用与对应的参数借用绑定在一起。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
struct Point(i32, i32);

/// 在 `points` 中搜索最接近 `query` 的点。
/// 假定 `points` 中至少有一个点。
fn find_nearest<'a>(points: &'a [Point], query: &Point) -> &'a Point {
 fn cab_distance(p1: &Point, p2: &Point) -> i32 {
 (p1.0 - p2.0).abs() + (p1.1 - p2.1).abs()
 }

 let mut nearest = None;
 for p in points {
 if let Some((_, nearest_dist)) = nearest {
 let dist = cab_distance(p, query);
 if dist < nearest_dist {
 nearest = Some((p, dist));
 }
 } else {
 nearest = Some((p, cab_distance(p, query)));
 };
 }

 nearest.map(|(p, _)| p).unwrap()
 // query // What happens if we do this instead?
}

fn main() {
 let points = &[Point(1, 0), Point(1, 0), Point(-1, 0), Point(0, -1)];
 let query = Point(0, 2);
 let nearest = find_nearest(points, &query);

 // 此时 `query` 未被借用。
 drop(query);

 dbg!(nearest);
}

折叠 find_nearest 的定义可能有助于把注意力放在函数签名上。函数内的实际逻辑较复杂，对借用分析而言并不重要。

3.6 生命周期省略

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/lifetime-elision.html

3.6 生命周期省略

函数参数与返回值的生命周期必须完整指定，但在大多数情况下 Rust 允许按几条简单规则省略生命周期。这不是推理（inference）——只是语法简写。

3.7 数据结构中的生命周期

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/lifetimes/struct-lifetimes.html

3.7 数据结构中的生命周期

若数据类型存储借用的数据，必须用生命周期标注：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
enum HighlightColor {
 Pink,
 Yellow,
}

#[derive(Debug)]
struct Highlight<'document> {
 slice: &'document str,
 color: HighlightColor,
}

fn main() {
 let doc = String::from("The quick brown fox jumps over the lazy dog.");
 let noun = Highlight { slice: &doc[16..19], color: HighlightColor::Yellow };
 let verb = Highlight { slice: &doc[20..25], color: HighlightColor::Pink };
 // drop(doc);
 dbg!(noun);
 dbg!(verb);
}

在上面的例子中，Highlight 上的标注强制要求：被包含的 &str 所依赖的底层数据，至少要与任何使用该数据的 Highlight 实例活得一样长。结构体不能比它所引用的数据活得更久。

若在 noun 或 verb 的生命周期结束之前丢弃 doc，借用检查器会报错。

带有借用数据的类型会迫使用户持有原始数据。这对创建轻量视图很有用，但通常也使它们更难使用。

可能的话，让数据结构直接拥有其数据。

某些内部有多个引用的结构体可以有多个生命周期标注。若除了结构体自身的生命周期外，还需要描述引用之间的生命周期关系，这就可能是必要的。那些是非常高级的用例。