|
|
## 生命周期与引用有效性
|
|
|
|
|
|
> [ch10-03-lifetime-syntax.md](https://github.com/rust-lang/book/blob/master/src/ch10-03-lifetime-syntax.md)
|
|
|
> <br>
|
|
|
> commit 426f3e4ec17e539ae9905ba559411169d303a031
|
|
|
|
|
|
当在第四章讨论 [“引用和借用”][references-and-borrowing] 部分时，我们遗漏了一个重要的细节：Rust 中的每一个引用都有其 **生命周期**（*lifetime*），也就是引用保持有效的作用域。大部分时候生命周期是隐含并可以推断的，正如大部分时候类型也是可以推断的一样。类似于当因为有多种可能类型的时候必须注明类型，也会出现引用的生命周期以一些不同方式相关联的情况，所以 Rust 需要我们使用泛型生命周期参数来注明他们的关系，这样就能确保运行时实际使用的引用绝对是有效的。
|
|
|
|
|
|
生命周期的概念某种程度上说不同于其他语言中类似的工具，毫无疑问这是 Rust 最与众不同的功能。虽然本章不可能涉及到它全部的内容，我们会讲到一些通常你可能会遇到的生命周期语法以便你熟悉这个概念。查看第十九章 “高级生命周期” 部分了解更多的细节。
|
|
|
|
|
|
### 生命周期避免了悬垂引用
|
|
|
|
|
|
生命周期的主要目标是避免悬垂引用，它会导致程序引用了非预期引用的数据。考虑一下示例 10-17 中的程序，它有一个外部作用域和一个内部作用域.
|
|
|
|
|
|
```rust,ignore,does_not_compile
|
|
|
{
|
|
|
let r;
|
|
|
|
|
|
{
|
|
|
let x = 5;
|
|
|
r = &x;
|
|
|
}
|
|
|
|
|
|
println!("r: {}", r);
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-17：尝试使用离开作用域的值的引用</span>
|
|
|
|
|
|
> 注意：示例 10-17、10-18 和 10-24 中声明了没有初始值的变量，所以这些变量存在于外部作用域。这乍看之下好像和 Rust 不允许存在空值相冲突。然而如果尝试在给它一个值之前使用这个变量，会出现一个编译时错误，这就说明了 Rust 确实不允许空值。
|
|
|
|
|
|
外部作用域声明了一个没有初值的变量 `r`，而内部作用域声明了一个初值为 5 的变量`x`。在内部作用域中，我们尝试将 `r` 的值设置为一个 `x` 的引用。接着在内部作用域结束后，尝试打印出 `r` 的值。这段代码不能编译因为 `r` 引用的值在尝试使用之前就离开了作用域。如下是错误信息：
|
|
|
|
|
|
```text
|
|
|
error[E0597]: `x` does not live long enough
|
|
|
--> src/main.rs:7:5
|
|
|
|
|
|
|
6 | r = &x;
|
|
|
| - borrow occurs here
|
|
|
7 | }
|
|
|
| ^ `x` dropped here while still borrowed
|
|
|
...
|
|
|
10 | }
|
|
|
| - borrowed value needs to live until here
|
|
|
```
|
|
|
|
|
|
变量 `x` 并没有 “存在的足够久”。其原因是 `x` 在到达第 7 行内部作用域结束时就离开了作用域。不过 `r` 在外部作用域仍是有效的；作用域越大我们就说它 “存在的越久”。如果 Rust 允许这段代码工作，`r` 将会引用在 `x` 离开作用域时被释放的内存，这时尝试对 `r` 做任何操作都不能正常工作。那么 Rust 是如何决定这段代码是不被允许的呢？这得益于借用检查器。
|
|
|
|
|
|
#### 借用检查器
|
|
|
|
|
|
Rust 编译器有一个 **借用检查器**（*borrow checker*），它比较作用域来确保所有的借用都是有效的。示例 10-18 展示了与示例 10-17 相同的例子不过带有变量生命周期的注释：
|
|
|
|
|
|
```rust,ignore,does_not_compile
|
|
|
{
|
|
|
let r; // ---------+-- 'a
|
|
|
// |
|
|
|
{ // |
|
|
|
let x = 5; // -+-- 'b |
|
|
|
r = &x; // | |
|
|
|
} // -+ |
|
|
|
// |
|
|
|
println!("r: {}", r); // |
|
|
|
} // ---------+
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-18：`r` 和 `x` 的生命周期注解，分别叫做 `'a` 和 `'b`</span>
|
|
|
|
|
|
这里将 `r` 的生命周期标记为 `'a` 并将 `x` 的生命周期标记为 `'b`。如你所见，内部的 `'b` 块要比外部的生命周期 `'a` 小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 `r` 拥有生命周期 `'a`，不过它引用了一个拥有生命周期 `'b` 的对象。程序被拒绝编译，因为生命周期 `'b` 比生命周期 `'a` 要小：被引用的对象比它的引用者存在的时间更短。
|
|
|
|
|
|
让我们看看示例 10-19 中这个并没有产生悬垂引用且可以正确编译的例子：
|
|
|
|
|
|
```rust
|
|
|
{
|
|
|
let x = 5; // ----------+-- 'b
|
|
|
// |
|
|
|
let r = &x; // --+-- 'a |
|
|
|
// | |
|
|
|
println!("r: {}", r); // | |
|
|
|
// --+ |
|
|
|
} // ----------+
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-19：一个有效的引用，因为数据比引用有着更长的生命周期</span>
|
|
|
|
|
|
这里 `x` 拥有生命周期 `'b`，比 `'a` 要大。这就意味着 `r` 可以引用 `x`：Rust 知道 `r` 中的引用在 `x` 有效的时候也总是有效的。
|
|
|
|
|
|
现在我们已经在一个具体的例子中展示了引用的生命周期位于何处，并讨论了 Rust 如何分析生命周期来保证引用总是有效的，接下来让我们聊聊在函数的上下文中参数和返回值的泛型生命周期。
|
|
|
|
|
|
### 函数中的泛型生命周期
|
|
|
|
|
|
让我们来编写一个返回两个字符串 slice 中较长者的函数。这个函数获取两个字符串 slice 并返回一个字符串 slice。一旦我们实现了 `longest` 函数，示例 10-20 中的代码应该会打印出 `The longest string is abcd`：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust,ignore
|
|
|
fn main() {
|
|
|
let string1 = String::from("abcd");
|
|
|
let string2 = "xyz";
|
|
|
|
|
|
let result = longest(string1.as_str(), string2);
|
|
|
println!("The longest string is {}", result);
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-20：`main` 函数调用 `longest` 函数来寻找两个字符串 slice 中较长的一个</span>
|
|
|
|
|
|
注意这个函数获取作为引用的字符串 slice，因为我们不希望 `longest` 函数获取参数的所有权。我们期望该函数接受 `String` 的 slice（参数 `string1` 的类型）和字符串字面值（包含于参数 `string2`）
|
|
|
|
|
|
参考之前第四章中的 [“字符串 slice 作为参数”][string-slices-as-parameters] 部分中更多关于为什么示例 10-20 的参数正符合我们期望的讨论。
|
|
|
|
|
|
如果尝试像示例 10-21 中那样实现 `longest` 函数，它并不能编译：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust,ignore,does_not_compile
|
|
|
fn longest(x: &str, y: &str) -> &str {
|
|
|
if x.len() > y.len() {
|
|
|
x
|
|
|
} else {
|
|
|
y
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-21：一个 `longest` 函数的实现，它返回两个字符串 slice 中较长者，现在还不能编译</span>
|
|
|
|
|
|
相应地会出现如下有关生命周期的错误：
|
|
|
|
|
|
```text
|
|
|
error[E0106]: missing lifetime specifier
|
|
|
--> src/main.rs:1:33
|
|
|
|
|
|
|
1 | fn longest(x: &str, y: &str) -> &str {
|
|
|
| ^ expected lifetime parameter
|
|
|
|
|
|
|
= help: this function's return type contains a borrowed value, but the
|
|
|
signature does not say whether it is borrowed from `x` or `y`
|
|
|
```
|
|
|
|
|
|
提示文本揭示了返回值需要一个泛型生命周期参数，因为 Rust 并不知道将要返回的引用是指向 `x` 或 `y`。事实上我们也不知道，因为函数体中 `if` 块返回一个 `x` 的引用而 `else` 块返回一个 `y` 的引用！
|
|
|
|
|
|
当我们定义这个函数的时候，并不知道传递给函数的具体值，所以也不知道到底是 `if` 还是 `else` 会被执行。我们也不知道传入的引用的具体生命周期，所以也就不能像示例 10-18 和 10-19 那样通过观察作用域来确定返回的引用是否总是有效。借用检查器自身同样也无法确定，因为它不知道 `x` 和 `y` 的生命周期是如何与返回值的生命周期相关联的。为了修复这个错误，我们将增加泛型生命周期参数来定义引用间的关系以便借用检查器可以进行分析。
|
|
|
|
|
|
### 生命周期注解语法
|
|
|
|
|
|
生命周期注解并不改变任何引用的生命周期的长短。与当函数签名中指定了泛型类型参数后就可以接受任何类型一样，当指定了泛型生命周期后函数也能接受任何生命周期的引用。生命周期注解描述了多个引用生命周期相互的关系，而不影响其生命周期。
|
|
|
|
|
|
生命周期注解有着一个不太常见的语法：生命周期参数名称必须以撇号（`'`）开头，其名称通常全是小写，类似于泛型其名称非常短。`'a` 是大多数人默认使用的名称。生命周期参数注解位于引用的 `&` 之后，并有一个空格来将引用类型与生命周期注解分隔开。
|
|
|
|
|
|
这里有一些例子：我们有一个没有生命周期参数的 `i32` 的引用，一个有叫做 `'a` 的生命周期参数的 `i32` 的引用，和一个生命周期也是 `'a` 的 `i32` 的可变引用：
|
|
|
|
|
|
```rust,ignore
|
|
|
&i32 // 引用
|
|
|
&'a i32 // 带有显式生命周期的引用
|
|
|
&'a mut i32 // 带有显式生命周期的可变引用
|
|
|
```
|
|
|
|
|
|
单个的生命周期注解本身没有多少意义，因为生命周期注解告诉 Rust 多个引用的泛型生命周期参数如何相互联系的。例如如果函数有一个生命周期 `'a` 的 `i32` 的引用的参数 `first`。还有另一个同样是生命周期 `'a` 的 `i32` 的引用的参数 `second`。这两个生命周期注解意味着引用 `first` 和 `second` 必须与这泛型生命周期存在得一样久。
|
|
|
|
|
|
### 函数签名中的生命周期注解
|
|
|
|
|
|
现在来看看 `longest` 函数的上下文中的生命周期。就像泛型类型参数，泛型生命周期参数需要声明在函数名和参数列表间的尖括号中。这里我们想要告诉 Rust 关于参数中的引用和返回值之间的限制是他们都必须拥有相同的生命周期，就像示例 10-22 中在每个引用中都加上了 `'a` 那样：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust
|
|
|
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
|
|
|
if x.len() > y.len() {
|
|
|
x
|
|
|
} else {
|
|
|
y
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-22：`longest` 函数定义指定了签名中所有的引用必须有相同的生命周期 `'a`</span>
|
|
|
|
|
|
这段代码能够编译并会产生我们希望得到的示例 10-20 中的 `main` 函数的结果。
|
|
|
|
|
|
现在函数签名表明对于某些生命周期 `'a`，函数会获取两个参数，他们都是与生命周期 `'a` 存在的一样长的字符串 slice。函数会返回一个同样也与生命周期 `'a` 存在的一样长的字符串 slice。这就是我们告诉 Rust 需要其保证的契约。记住通过在函数签名中指定生命周期参数时，我们并没有改变任何传入后返回的值的生命周期。而是指出任何不遵守这个协议的传入值都将被借用检查器拒绝。注意 `longest` 函数并不需要知道 `x` 和 `y` 具体会存在多久，而只需要知道有某个可以被 `'a` 替代的作用域将会满足这个签名。
|
|
|
|
|
|
当在函数中使用生命周期注解时，这些注解出现在函数签名中，而不存在于函数体中的任何代码中。这是因为 Rust 能够分析函数中代码而不需要任何协助，不过当函数引用或被函数之外的代码引用时，让 Rust 自身分析出参数或返回值的生命周期几乎是不可能的。这些生命周期在每次函数被调用时都可能不同。这也就是为什么我们需要手动标记生命周期。
|
|
|
|
|
|
当具体的引用被传递给 `longest` 时，被 `'a` 所替代的具体生命周期是 `x` 的作用域与 `y` 的作用域相重叠的那一部分。换一种说法就是泛型生命周期 `'a` 的具体生命周期等同于 `x` 和 `y` 的生命周期中较小的那一个。因为我们用相同的生命周期参数 `'a` 标注了返回的引用值，所以返回的引用值就能保证在 `x` 和 `y` 中较短的那个生命周期结束之前保持有效。
|
|
|
|
|
|
让我们看看如何通过传递拥有不同具体生命周期的引用来限制 `longest` 函数的使用。示例 10-23 是一个很直观的例子。
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust
|
|
|
# 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);
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-23：通过拥有不同的具体生命周期的 `String` 值调用 `longest` 函数</span>
|
|
|
|
|
|
在这个例子中，`string1` 直到外部作用域结束都是有效的，`string2` 则在内部作用域中是有效的，而 `result` 则引用了一些直到内部作用域结束都是有效的值。借用检查器认可这些代码；它能够编译和运行，并打印出 `The longest string is long string is long`。
|
|
|
|
|
|
接下来，让我们尝试另外一个例子，该例子揭示了 `result` 的引用的生命周期必须是两个参数中较短的那个。以下代码将 `result` 变量的声明移动出内部作用域，但是将 `result` 和 `string2` 变量的赋值语句一同留在内部作用域中。接着，使用了变量 `result` 的 `println!` 也被移动到内部作用域之外。注意示例 10-24 中的代码不能通过编译：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust,ignore,does_not_compile
|
|
|
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);
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-24：尝试在 `string2` 离开作用域之后使用 `result` </span>
|
|
|
|
|
|
如果尝试编译会出现如下错误：
|
|
|
|
|
|
```text
|
|
|
error[E0597]: `string2` does not live long enough
|
|
|
--> src/main.rs:15:5
|
|
|
|
|
|
|
14 | result = longest(string1.as_str(), string2.as_str());
|
|
|
| ------- borrow occurs here
|
|
|
15 | }
|
|
|
| ^ `string2` dropped here while still borrowed
|
|
|
16 | println!("The longest string is {}", result);
|
|
|
17 | }
|
|
|
| - borrowed value needs to live until here
|
|
|
```
|
|
|
|
|
|
错误表明为了保证 `println!` 中的 `result` 是有效的，`string2` 需要直到外部作用域结束都是有效的。Rust 知道这些是因为（`longest`）函数的参数和返回值都使用了相同的生命周期参数 `'a`。
|
|
|
|
|
|
如果从人的角度读上述代码，我们可能会觉得这个代码是正确的。 `string1` 更长，因此 `result` 会包含指向 `string1` 的引用。因为 `string1` 尚未离开作用域，对于 `println!` 来说 `string1` 的引用仍然是有效的。然而，我们通过生命周期参数告诉 Rust 的是： `longest` 函数返回的引用的生命周期应该与传入参数的生命周期中较短那个保持一致。因此，借用检查器不允许示例 10-24 中的代码，因为它可能会存在无效的引用。
|
|
|
|
|
|
请尝试更多采用不同的值和不同生命周期的引用作为 `longest` 函数的参数和返回值的实验。并在开始编译前猜想你的实验能否通过借用检查器，接着编译一下看看你的理解是否正确！
|
|
|
|
|
|
### 深入理解生命周期
|
|
|
|
|
|
指定生命周期参数的正确方式依赖函数实现的具体功能。例如，如果将 `longest` 函数的实现修改为总是返回第一个参数而不是最长的字符串 slice，就不需要为参数 `y` 指定一个生命周期。如下代码将能够编译：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust
|
|
|
fn longest<'a>(x: &'a str, y: &str) -> &'a str {
|
|
|
x
|
|
|
}
|
|
|
```
|
|
|
|
|
|
在这个例子中，我们为参数 `x` 和返回值指定了生命周期参数 `'a`，不过没有为参数 `y` 指定，因为 `y` 的生命周期与参数 `x` 和返回值的生命周期没有任何关系。
|
|
|
|
|
|
当从函数返回一个引用，返回值的生命周期参数需要与一个参数的生命周期参数相匹配。如果返回的引用 **没有** 指向任何一个参数，那么唯一的可能就是它指向一个函数内部创建的值，它将会是一个悬垂引用，因为它将会在函数结束时离开作用域。尝试考虑这个并不能编译的 `longest` 函数实现：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```rust,ignore,does_not_compile
|
|
|
fn longest<'a>(x: &str, y: &str) -> &'a str {
|
|
|
let result = String::from("really long string");
|
|
|
result.as_str()
|
|
|
}
|
|
|
```
|
|
|
|
|
|
即便我们为返回值指定了生命周期参数 `'a`，这个实现却编译失败了，因为返回值的生命周期与参数完全没有关联。这里是会出现的错误信息：
|
|
|
|
|
|
```text
|
|
|
error[E0597]: `result` does not live long enough
|
|
|
--> src/main.rs:3:5
|
|
|
|
|
|
|
3 | result.as_str()
|
|
|
| ^^^^^^ does not live long enough
|
|
|
4 | }
|
|
|
| - borrowed value only lives until here
|
|
|
|
|
|
|
note: borrowed value must be valid for the lifetime 'a as defined on the
|
|
|
function body at 1:1...
|
|
|
--> src/main.rs:1:1
|
|
|
|
|
|
|
1 | / fn longest<'a>(x: &str, y: &str) -> &'a str {
|
|
|
2 | | let result = String::from("really long string");
|
|
|
3 | | result.as_str()
|
|
|
4 | | }
|
|
|
| |_^
|
|
|
```
|
|
|
|
|
|
出现的问题是 `result` 在 `longest` 函数的结尾将离开作用域并被清理，而我们尝试从函数返回一个 `result` 的引用。无法指定生命周期参数来改变悬垂引用，而且 Rust 也不允许我们创建一个悬垂引用。在这种情况，最好的解决方案是返回一个有所有权的数据类型而不是一个引用，这样函数调用者就需要负责清理这个值了。
|
|
|
|
|
|
综上，生命周期语法是用于将函数的多个参数与其返回值的生命周期进行关联的。一旦他们形成了某种关联，Rust 就有了足够的信息来允许内存安全的操作并阻止会产生悬垂指针亦或是违反内存安全的行为。
|
|
|
|
|
|
### 结构体定义中的生命周期注解
|
|
|
|
|
|
目前为止，我们只定义过有所有权类型的结构体。接下来，我们将定义包含引用的结构体，不过这需要为结构体定义中的每一个引用添加生命周期注解。示例 10-25 中有一个存放了一个字符串 slice 的结构体 `ImportantExcerpt`：
|
|
|
|
|
|
<span class="filename">文件名: src/main.rs</span>
|
|
|
|
|
|
```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()
|
|
|
.expect("Could not find a '.'");
|
|
|
let i = ImportantExcerpt { part: first_sentence };
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-25：一个存放引用的结构体，所以其定义需要生命周期注解</span>
|
|
|
|
|
|
这个结构体有一个字段，`part`，它存放了一个字符串 slice，这是一个引用。类似于泛型参数类型，必须在结构体名称后面的尖括号中声明泛型生命周期参数，以便在结构体定义中使用生命周期参数。这个注解意味着 `ImportantExcerpt` 的实例不能比其 `part` 字段中的引用存在的更久。
|
|
|
|
|
|
这里的 `main` 函数创建了一个 `ImportantExcerpt` 的实例，它存放了变量 `novel` 所拥有的 `String` 的第一个句子的引用。`novel` 的数据在 `ImportantExcerpt` 实例创建之前就存在。另外，直到 `ImportantExcerpt` 离开作用域之后 `novel` 都不会离开作用域，所以 `ImportantExcerpt` 实例中的引用是有效的
|
|
|
|
|
|
### 生命周期省略（Lifetime Elision）
|
|
|
|
|
|
现在我们已经知道了每一个引用都有一个生命周期，而且我们需要为那些使用了引用的函数或结构体指定生命周期。然而，第四章的示例 4-9 中有一个函数，如示例 10-26 所示，它没有生命周期注解却能编译成功：
|
|
|
|
|
|
<span class="filename">文件名: src/lib.rs</span>
|
|
|
|
|
|
```rust
|
|
|
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[..]
|
|
|
}
|
|
|
```
|
|
|
|
|
|
<span class="caption">示例 10-26：示例 4-9 定义了一个没有使用生命周期注解的函数，即便其参数和返回值都是引用</span>
|
|
|
|
|
|
这个函数没有生命周期注解却能编译是由于一些历史原因：在早期版本（pre-1.0）的 Rust 中，这的确是不能编译的。每一个引用都必须有明确的生命周期。那时的函数签名将会写成这样：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn first_word<'a>(s: &'a str) -> &'a str {
|
|
|
```
|
|
|
|
|
|
在编写了很多 Rust 代码后，Rust 团队发现在特定情况下 Rust 程序员们总是重复地编写一模一样的生命周期注解。这些场景是可预测的并且遵循几个明确的模式。接着 Rust 团队就把这些模式编码进了 Rust 编译器中，如此借用检查器在这些情况下就能推断出生命周期而不再强制程序员显式的增加注解。
|
|
|
|
|
|
这里我们提到一些 Rust 的历史是因为更多的明确的模式被合并和添加到编译器中是完全可能的。未来只会需要更少的生命周期注解。
|
|
|
|
|
|
被编码进 Rust 引用分析的模式被称为 **生命周期省略规则**（*lifetime elision rules*）。这并不是需要程序员遵守的规则；这些规则是一系列特定的场景，此时编译器会考虑，如果代码符合这些场景，就无需明确指定生命周期。
|
|
|
|
|
|
省略规则并不提供完整的推断：如果 Rust 在明确遵守这些规则的前提下变量的生命周期仍然是模棱两可的话，它不会猜测剩余引用的生命周期应该是什么。在这种情况，编译器会给出一个错误，这可以通过增加对应引用之间相联系的生命周期注解来解决。
|
|
|
|
|
|
函数或方法的参数的生命周期被称为 **输入生命周期**（*input lifetimes*），而返回值的生命周期被称为 **输出生命周期**（*output lifetimes*）。
|
|
|
|
|
|
编译器采用三条规则来判断引用何时不需要明确的注解。第一条规则适用于输入生命周期，后两条规则适用于输出生命周期。如果编译器检查完这三条规则后仍然存在没有计算出生命周期的引用，编译器将会停止并生成错误。这些规则适用于 `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-26 中 `first_word` 函数签名中的引用的生命周期。开始时签名中的引用并没有关联任何生命周期：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn first_word(s: &str) -> &str {
|
|
|
```
|
|
|
|
|
|
接着编译器应用第一条规则，也就是每个引用参数都有其自己的生命周期。我们像往常一样称之为 `'a`，所以现在签名看起来像这样：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn first_word<'a>(s: &'a str) -> &str {
|
|
|
```
|
|
|
|
|
|
对于第二条规则，因为这里正好只有一个输入生命周期参数所以是适用的。第二条规则表明输入参数的生命周期将被赋予输出生命周期参数，所以现在签名看起来像这样：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn first_word<'a>(s: &'a str) -> &'a str {
|
|
|
```
|
|
|
|
|
|
现在这个函数签名中的所有引用都有了生命周期，如此编译器可以继续它的分析而无须程序员标记这个函数签名中的生命周期。
|
|
|
|
|
|
让我们再看看另一个例子，这次我们从示例 10-21 中没有生命周期参数的 `longest` 函数开始：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn longest(x: &str, y: &str) -> &str {
|
|
|
```
|
|
|
|
|
|
再次假设我们自己就是编译器并应用第一条规则：每个引用参数都有其自己的生命周期。这次有两个参数，所以就有两个（不同的）生命周期：
|
|
|
|
|
|
```rust,ignore
|
|
|
fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {
|
|
|
```
|
|
|
|
|
|
再来应用第二条规则，因为函数存在多个输入生命周期，它并不适用于这种情况。再来看第三条规则，它同样也不适用，这是因为没有 `self` 参数。应用了三个规则之后编译器还没有计算出返回值类型的生命周期。这就是为什么在编译示例 10-21 的代码时会出现错误的原因：编译器使用所有已知的生命周期省略规则，仍不能计算出签名中所有引用的生命周期。
|
|
|
|
|
|
因为第三条规则真正能够适用的就只有方法签名，现在就让我们看看那种情况中的生命周期，并看看为什么这条规则意味着我们经常不需要在方法签名中标注生命周期。
|
|
|
|
|
|
### 方法定义中的生命周期注解
|
|
|
|
|
|
当为带有生命周期的结构体实现方法时，其语法依然类似示例 10-11 中展示的泛型类型参数的语法。声明和使用生命周期参数的位置依赖于生命周期参数是否同结构体字段或方法参数和返回值相关。
|
|
|
|
|
|
（实现方法时）结构体字段的生命周期必须总是在 `impl` 关键字之后声明并在结构体名称之后被使用，因为这些生命周期是结构体类型的一部分。
|
|
|
|
|
|
`impl` 块里的方法签名中，引用可能与结构体字段中的引用相关联，也可能是独立的。另外，生命周期省略规则也经常让我们无需在方法签名中使用生命周期注解。让我们看看一些使用示例 10-25 中定义的结构体 `ImportantExcerpt` 的例子。
|
|
|
|
|
|
首先，这里有一个方法 `level`。其唯一的参数是 `self` 的引用，而且返回值只是一个 `i32`，并不引用任何值：
|
|
|
|
|
|
```rust
|
|
|
# struct ImportantExcerpt<'a> {
|
|
|
# part: &'a str,
|
|
|
# }
|
|
|
#
|
|
|
impl<'a> ImportantExcerpt<'a> {
|
|
|
fn level(&self) -> i32 {
|
|
|
3
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
`impl` 之后和类型名称之后的生命周期参数是必要的，不过因为第一条生命周期规则我们并不必须标注 `self` 引用的生命周期。
|
|
|
|
|
|
这里是一个适用于第三条生命周期省略规则的例子：
|
|
|
|
|
|
```rust
|
|
|
# struct ImportantExcerpt<'a> {
|
|
|
# part: &'a str,
|
|
|
# }
|
|
|
#
|
|
|
impl<'a> ImportantExcerpt<'a> {
|
|
|
fn announce_and_return_part(&self, announcement: &str) -> &str {
|
|
|
println!("Attention please: {}", announcement);
|
|
|
self.part
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
这里有两个输入生命周期，所以 Rust 应用第一条生命周期省略规则并给予 `&self` 和 `announcement` 他们各自的生命周期。接着，因为其中一个参数是 `&self`，返回值类型被赋予了 `&self` 的生命周期，这样所有的生命周期都被计算出来了。
|
|
|
|
|
|
### 静态生命周期
|
|
|
|
|
|
这里有一种特殊的生命周期值得讨论：`'static`，其生命周期**能够**存活于整个程序期间。所有的字符串字面值都拥有 `'static` 生命周期，我们也可以选择像下面这样标注出来：
|
|
|
|
|
|
```rust
|
|
|
let s: &'static str = "I have a static lifetime.";
|
|
|
```
|
|
|
|
|
|
这个字符串的文本被直接储存在程序的二进制文件中而这个文件总是可用的。因此所有的字符串字面值都是 `'static` 的。
|
|
|
|
|
|
你可能在错误信息的帮助文本中见过使用 `'static` 生命周期的建议，不过将引用指定为 `'static` 之前，思考一下这个引用是否真的在整个程序的生命周期里都有效。你可能会考虑希望它一直有效，如果可能的话。大部分情况，代码中的问题是尝试创建一个悬垂引用或者可用的生命周期不匹配，请解决这些问题而不是指定一个 `'static` 的生命周期。
|
|
|
|
|
|
### 结合泛型类型参数、trait bounds 和生命周期
|
|
|
|
|
|
让我们简要的看一下在同一函数中指定泛型类型参数、trait bounds 和生命周期的语法！
|
|
|
|
|
|
```rust
|
|
|
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-22 中那个返回两个字符串 slice 中较长者的 `longest` 函数，不过带有一个额外的参数 `ann`。`ann` 的类型是泛型 `T`，它可以被放入任何实现了 `where` 从句中指定的 `Display` trait 的类型。这个额外的参数会在函数比较字符串 slice 的长度之前被打印出来，这也就是为什么 `Display` trait bound 是必须的。因为生命周期也是泛型，所以生命周期参数 `'a` 和泛型类型参数 `T` 都位于函数名后的同一尖括号列表中。
|
|
|
|
|
|
## 总结
|
|
|
|
|
|
这一章介绍了很多的内容！现在你知道了泛型类型参数、trait 和 trait bounds 以及泛型生命周期类型，你已经准备好编写既不重复又能适用于多种场景的代码了。泛型类型参数意味着代码可以适用于不同的类型。trait 和 trait bounds 保证了即使类型是泛型的，这些类型也会拥有所需要的行为。由生命周期注解所指定的引用生命周期之间的关系保证了这些灵活多变的代码不会出现悬垂引用。而所有的这一切发生在编译时所以不会影响运行时效率！
|
|
|
|
|
|
你可能不会相信，这个领域还有更多需要学习的内容：第十七章会讨论 trait 对象，这是另一种使用 trait 的方式。第十九章会涉及到生命周期注解更复杂的场景。第二十章讲解一些高级的类型系统功能。不过接下来，让我们聊聊如何在 Rust 中编写测试，来确保代码的所有功能能像我们希望的那样工作！
|
|
|
|
|
|
[references-and-borrowing]:
|
|
|
ch04-02-references-and-borrowing.html#references-and-borrowing
|
|
|
[string-slices-as-parameters]:
|
|
|
ch04-03-slices.html#string-slices-as-parameters
|
