【Rust学习】04_2引用和借用

前言

在这章我们将开始学习Rust的引用和借用，它们是Rust中重要的概念，它们允许我们创建可变引用，以及创建不可变引用。

内容

引用和借用

在下面的示例中，我们必须将 String 返回给调用函数，以便在调用 calculate_length 后仍能使用 String，因为 String 被移动到了 calculate_length 内。

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

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

首先，请注意变量声明和函数返回值中的所有元组代码都消失了。注意我们传递 &s1 给 calculate_length，同时在函数定义中，我们获取 &String 而不是 String。
这些 & 符号表示引用，它们允许您引用某个值，而无需获得其所有权。

注意：与使用 & 引用相反的操作是 解引用（dereferencing），它使用解引用运算符，*。

让我们仔细看看这里的函数调用：

let s1 = String::from("hello");

let len = calculate_length(&s1);

该 &s1 语法允许我们创建一个指向 s1 的引用 ，但不拥有它。因为它不拥有它，所以当引用停止使用时，它指向的值不会被删除。

同样，函数的签名用 & 来表明参数 s 的类型是引用。让我们添加一些解释性注释：

fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
    s.len()
} // 这里，s 离开了作用域。但因为它并不拥有引用值的所有权，
  // 所以什么也不会发生

变量 s 有效的作用域与任何函数参数的作用域相同，但是当停止使用 s 时，引用指向的值不会被删除，因为它没有 s 的所有权。当函数将引用作为参数而不是实际值时，我们不需要返回值来归还所有权，因为我们从未拥有所有权。

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

如果我们尝试修改借来的变量，会发生什么呢？

fn main() {
    let s = String::from("hello");
    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

现在我们来运行一下，这时候我们会得到一个错误：

error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
  --> src/main.rs:19:5
   |
19 |     some_string.push_str(", world");
   |     ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider changing this to be a mutable reference
   |
18 | fn change(some_string: &mut String) {
   |                         +++

正如变量默认情况下是不可变的一样，引用也是不可变的。不允许修改我们引用的内容。

可变引用

们只需进行一些小的调整来修改借来的值，这些调整使用可变引用：

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

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

不过可变引用有一个很大的限制：在同一时间，只能有一个对某一特定数据的可变引用。尝试创建两个可变引用的代码将会失败：

 let mut s = String::from("hello");

let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM

println!("{}, {}, and {}", r1, r2, r3);

错误如下：

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:37:14
   |
35 |     let r1 = &s; // no problem
   |              -- immutable borrow occurs here
36 |     let r2 = &s; // no problem
37 |     let r3 = &mut s; // BIG PROBLEM
   |              ^^^^^^ mutable borrow occurs here
38 |
39 |     println!("{}, {}, and {}", r1, r2, r3);
   |                                -- immutable borrow later used here

我们不能有一个可变的引用，因为我们有一个不可变的引用指向相同的值。

不可变引用的用户不希望值突然从他们下面改变出来！但是，允许多个不可变引用，因为任何只读取数据的人都无法影响其他任何人对数据的读取。

请注意，引用的范围从引入它的地方开始，一直持续到最后一次使用该引用。例如，此代码将进行编译，因为不可变引用的最后一次使用（println！）发生在引入可变引用之前：

    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // variables r1 and r2 will not be used after this point

    let r3 = &mut s; // no problem
    println!("{r3}");

不可变引用 r1 和 r2 的作用域在 println！ 之后结束，它们最后使用的位置，即在创建可变引用 r3 之前。这些作用域不重叠，因此允许使用此代码：编译器可以看出在作用域结束之前的某个时间点不再使用引用。

尽管借用错误有时可能会令人沮丧，但请记住，这是 Rust 编译器尽早指出潜在的错误（在编译时而不是在运行时），并准确地告诉你问题出在哪里。这样，你就不必追踪为什么你的数据不是你想象的那样。

悬垂引用

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

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

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

错误如下：

error[E0106]: missing lifetime specifier
  --> src/main.rs:60:16
   |
60 | fn dangle() -> &String {
   |                ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
60 | fn dangle() -> &'static String {
   |                 +++++++
help: instead, you are more likely to want to return an owned value
   |
60 - fn dangle() -> &String {
60 + fn dangle() -> String {
   |

此错误消息指的是我们尚未介绍的功能：生存期。我们将在第 10 章中详细讨论生命周期。但是，如果您忽略有关生存期的部分，则该消息确实包含了为什么此代码有问题的关键：

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

让我们仔细看看在dangle(悬垂)代码的每个阶段到底发生了什么：

fn dangle() -> &String { // dangle 返回一个字符串的引用

    let s = String::from("hello"); // s 是一个新的字符串

    &s // 返回字符串s的引用
} // 这时候 s 的作用域结束，s 被丢弃，s 的内存被释放。
  // Danger!

因为 s 是在 dangle 函数内部创建的，所以当 dangle 的代码完成后，s 将被释放。当我们试图返回对它的引用。这意味着此引用将指向无效的 String。这可不对！Rust 不允许我们这样做。

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

fn no_dangle() -> String {
    let s = String::from("hello");
    s
}

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

引用的规则

让我们回顾一下我们讨论过的关于引用的内容：

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

接下来，我们将查看一种不同类型的引用：切片(slices)。