引用与借用

ch04-02-references-and-borrowing.md
commit d82136cbdc91c598ef9997493aa577b1a349565e

示例 4-5 中的元组代码有这样一个问题:我们必须将 String 返回给调用函数,以便在调用 calculate_length 后仍能使用 String,因为 String 被移动到了 calculate_length 内。相反我们可以提供一个 String 值的引用(reference)。引用reference)像一个指针,因为它是一个地址,我们可以由此访问储存于该地址的属于其他变量的数据。 与指针不同,引用确保指向某个特定类型的有效值。

下面是如何定义并使用一个(新的)calculate_length 函数,它以一个对象的引用作为参数而不是获取值的所有权:

文件名: src/main.rs

  1. fn main() {
  2. let s1 = String::from("hello");
  3. let len = calculate_length(&s1);
  4. println!("The length of '{}' is {}.", s1, len);
  5. }
  6. fn calculate_length(s: &String) -> usize {
  7. s.len()
  8. }

首先,注意变量声明和函数返回值中的所有元组代码都消失了。其次,注意我们传递 &s1calculate_length,同时在函数定义中,我们获取 &String 而不是 String。这些 & 符号就是 引用,它们允许你使用值但不获取其所有权。图 4-5 展示了一张示意图。 &String s pointing at String s1 图 4-5:&String s 指向 String s1 示意图

注意:与使用 & 引用相反的操作是 解引用dereferencing),它使用解引用运算符,*。我们将会在第八章遇到一些解引用运算符,并在第十五章详细讨论解引用。

仔细看看这个函数调用:

  1. fn main() {
  2. let s1 = String::from("hello");
  3. let len = calculate_length(&s1);
  4. println!("The length of '{}' is {}.", s1, len);
  5. }
  6. fn calculate_length(s: &String) -> usize {
  7. s.len()
  8. }

&s1 语法让我们创建一个 指向s1 的引用,但是并不拥有它。因为并不拥有这个值,所以当引用停止使用时,它所指向的值也不会被丢弃。

同理,函数签名使用 & 来表明参数 s 的类型是一个引用。让我们增加一些解释性的注释:

  1. fn main() {
  2. let s1 = String::from("hello");
  3. let len = calculate_length(&s1);
  4. println!("The length of '{}' is {}.", s1, len);
  5. }
  6. fn calculate_length(s: &String) -> usize { // s是String的引用
  7. s.len()
  8. } // 这里,s 离开了作用域。但因为它并不拥有引用值的所有权,
  9. // 所以什么也不会发生

变量 s 有效的作用域与函数参数的作用域一样,不过当 s 停止使用时并不丢弃引用指向的数据,因为 s 并没有所有权。当函数使用引用而不是实际值作为参数,无需返回值来交还所有权,因为就不曾拥有所有权。

我们将创建一个引用的行为称为 借用borrowing)。正如现实生活中,如果一个人拥有某样东西,你可以从他那里借来。当你使用完毕,必须还回去。我们并不拥有它。

如果我们尝试修改借用的变量呢?尝试示例 4-6 中的代码。剧透:这行不通!

文件名: src/main.rs

  1. fn main() {
  2. let s = String::from("hello");
  3. change(&s);
  4. }
  5. fn change(some_string: &String) {
  6. some_string.push_str(", world");
  7. }

示例 4-6:尝试修改借用的值

这里是错误:

  1. $ cargo run
  2. Compiling ownership v0.1.0 (file:///projects/ownership)
  3. error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
  4. --> src/main.rs:8:5
  5. |
  6. 7 | fn change(some_string: &String) {
  7. | ------- help: consider changing this to be a mutable reference: `&mut String`
  8. 8 | some_string.push_str(", world");
  9. | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  10. For more information about this error, try `rustc --explain E0596`.
  11. error: could not compile `ownership` due to previous error

正如变量默认是不可变的,引用也一样。(默认)不允许修改引用的值。

可变引用

我们通过一个小调整就能修复示例 4-6 代码中的错误,允许我们修改一个借用的值,这就是 可变引用mutable reference):

文件名: src/main.rs

  1. fn main() {
  2. let mut s = String::from("hello");
  3. change(&mut s);
  4. }
  5. fn change(some_string: &mut String) {
  6. some_string.push_str(", world");
  7. }

首先,我们必须将 s 改为 mut。然后在调用 change 函数的地方创建一个可变引用 &mut s,并更新函数签名以接受一个可变引用 some_string: &mut String。这就非常清楚地表明,change 函数将改变它所借用的值。

可变引用有一个很大的限制:如果你有一个对该变量的可变引用,你就不能再创建对该变量的引用。这些尝试创建两个 s 的可变引用的代码会失败:

文件名: src/main.rs

  1. fn main() {
  2. let mut s = String::from("hello");
  3. let r1 = &mut s;
  4. let r2 = &mut s;
  5. println!("{}, {}", r1, r2);
  6. }

错误如下:

  1. $ cargo run
  2. Compiling ownership v0.1.0 (file:///projects/ownership)
  3. error[E0499]: cannot borrow `s` as mutable more than once at a time
  4. --> src/main.rs:5:14
  5. |
  6. 4 | let r1 = &mut s;
  7. | ------ first mutable borrow occurs here
  8. 5 | let r2 = &mut s;
  9. | ^^^^^^ second mutable borrow occurs here
  10. 6 |
  11. 7 | println!("{}, {}", r1, r2);
  12. | -- first borrow later used here
  13. For more information about this error, try `rustc --explain E0499`.
  14. error: could not compile `ownership` due to previous error

这个报错说这段代码是无效的,因为我们不能在同一时间多次将 s 作为可变变量借用。第一个可变的借入在 r1 中,并且必须持续到在 println! 中使用它,但是在那个可变引用的创建和它的使用之间,我们又尝试在 r2 中创建另一个可变引用,该引用借用与 r1 相同的数据。

这一限制以一种非常小心谨慎的方式允许可变性,防止同一时间对同一数据存在多个可变引用。新 Rustacean 们经常难以适应这一点,因为大部分语言中变量任何时候都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。数据竞争data race)类似于竞态条件,它可由这三个行为造成:

  • 两个或更多指针同时访问同一数据。
  • 至少有一个指针被用来写入数据。
  • 没有同步数据访问的机制。

数据竞争会导致未定义行为,难以在运行时追踪,并且难以诊断和修复;Rust 避免了这种情况的发生,因为它甚至不会编译存在数据竞争的代码!

一如既往,可以使用大括号来创建一个新的作用域,以允许拥有多个可变引用,只是不能 同时 拥有:

  1. fn main() {
  2. let mut s = String::from("hello");
  3. {
  4. let r1 = &mut s;
  5. } // r1 在这里离开了作用域,所以我们完全可以创建一个新的引用
  6. let r2 = &mut s;
  7. }

Rust 在同时使用可变与不可变引用时也采用的类似的规则。这些代码会导致一个错误:

  1. fn main() {
  2. let mut s = String::from("hello");
  3. let r1 = &s; // 没问题
  4. let r2 = &s; // 没问题
  5. let r3 = &mut s; // 大问题
  6. println!("{}, {}, and {}", r1, r2, r3);
  7. }

错误如下:

  1. $ cargo run
  2. Compiling ownership v0.1.0 (file:///projects/ownership)
  3. error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  4. --> src/main.rs:6:14
  5. |
  6. 4 | let r1 = &s; // no problem
  7. | -- immutable borrow occurs here
  8. 5 | let r2 = &s; // no problem
  9. 6 | let r3 = &mut s; // BIG PROBLEM
  10. | ^^^^^^ mutable borrow occurs here
  11. 7 |
  12. 8 | println!("{}, {}, and {}", r1, r2, r3);
  13. | -- immutable borrow later used here
  14. For more information about this error, try `rustc --explain E0502`.
  15. error: could not compile `ownership` due to previous error

哇哦!我们 不能在拥有不可变引用的同时拥有可变引用。

不可变引用的用户可不希望在他们的眼皮底下值就被意外的改变了!然而,多个不可变引用是可以的,因为没有哪个只能读取数据的人有能力影响其他人读取到的数据。

注意一个引用的作用域从声明的地方开始一直持续到最后一次使用为止。例如,因为最后一次使用不可变引用(println!),发生在声明可变引用之前,所以如下代码是可以编译的:

  1. fn main() {
  2. let mut s = String::from("hello");
  3. let r1 = &s; // 没问题
  4. let r2 = &s; // 没问题
  5. println!("{} and {}", r1, r2);
  6. // 此位置之后 r1 和 r2 不再使用
  7. let r3 = &mut s; // 没问题
  8. println!("{}", r3);
  9. }

不可变引用 r1r2 的作用域在 println! 最后一次使用之后结束,这也是创建可变引用 r3 的地方。它们的作用域没有重叠,所以代码是可以编译的。编译器在作用域结束之前判断不再使用的引用的能力被称为 非词法作用域生命周期Non-Lexical Lifetimes,简称 NLL)。你可以在 The Edition Guide 中阅读更多关于它的信息。

尽管这些错误有时使人沮丧,但请牢记这是 Rust 编译器在提前指出一个潜在的 bug(在编译时而不是在运行时)并精准显示问题所在。这样你就不必去跟踪为何数据并不是你想象中的那样。

悬垂引用(Dangling References)

在具有指针的语言中,很容易通过释放内存时保留指向它的指针而错误地生成一个 悬垂指针dangling pointer),所谓悬垂指针是其指向的内存可能已经被分配给其它持有者。相比之下,在 Rust 中编译器确保引用永远也不会变成悬垂状态:当你拥有一些数据的引用,编译器确保数据不会在其引用之前离开作用域。

让我们尝试创建一个悬垂引用,Rust 会通过一个编译时错误来避免:

文件名: src/main.rs

  1. fn main() {
  2. let reference_to_nothing = dangle();
  3. }
  4. fn dangle() -> &String {
  5. let s = String::from("hello");
  6. &s
  7. }

这里是错误:

  1. $ cargo run
  2. Compiling ownership v0.1.0 (file:///projects/ownership)
  3. error[E0106]: missing lifetime specifier
  4. --> src/main.rs:5:16
  5. |
  6. 5 | fn dangle() -> &String {
  7. | ^ expected named lifetime parameter
  8. |
  9. = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
  10. help: consider using the `'static` lifetime
  11. |
  12. 5 | fn dangle() -> &'static String {
  13. | ~~~~~~~~
  14. For more information about this error, try `rustc --explain E0106`.
  15. error: could not compile `ownership` due to previous error

错误信息引用了一个我们还未介绍的功能:生命周期(lifetimes)。第十章会详细介绍生命周期。不过,如果你不理会生命周期部分,错误信息中确实包含了为什么这段代码有问题的关键信息:

  1. this function's return type contains a borrowed value, but there is no value
  2. for it to be borrowed from

让我们仔细看看我们的 dangle 代码的每一步到底发生了什么:

文件名: src/main.rs

  1. fn main() {
  2. let reference_to_nothing = dangle();
  3. }
  4. fn dangle() -> &String { // dangle 返回一个字符串的引用
  5. let s = String::from("hello"); // s 是一个新字符串
  6. &s // 返回字符串 s 的引用
  7. } // 这里 s 离开作用域并被丢弃。其内存被释放。
  8. // 危险!

因为 s 是在 dangle 函数内创建的,当 dangle 的代码执行完毕后,s 将被释放。不过我们尝试返回它的引用。这意味着这个引用会指向一个无效的 String,这可不对!Rust 不会允许我们这么做。

这里的解决方法是直接返回 String

  1. fn main() {
  2. let string = no_dangle();
  3. }
  4. fn no_dangle() -> String {
  5. let s = String::from("hello");
  6. s
  7. }

这样就没有任何错误了。所有权被移动出去,所以没有值被释放。

引用的规则

让我们概括一下之前对引用的讨论:

  • 在任意给定时间,要么 只能有一个可变引用,要么 只能有多个不可变引用。
  • 引用必须总是有效的。

接下来,我们来看看另一种不同类型的引用:slice。