引用和借用
列表 4-5 中元组代码的问题在于我们必须将 String 返回给调用函数，这样我们才能在调用 calculate_length 之后继续使用 String，因为 String 已经被移动到了 calculate_length 中。相反，我们可以提供一个指向 String 值的引用。一个 引用 类似于指针，它是一个我们可以跟随的地址，用于访问存储在该地址的数据；这些数据由其他某个变量拥有。与指针不同，引用在其生命周期内保证指向特定类型的有效值。
这里是如何定义和使用一个calculate_length函数，该函数以对象的引用作为参数，而不是获取值的所有权：
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{s1}' is {len}."); } fn calculate_length(s: &String) -> usize { s.len() }
首先，注意变量声明和函数返回值中的所有元组代码都消失了。其次，注意我们传递&s1到calculate_length，在其定义中，我们接受&String而不是String。这些引用符号代表引用，它们允许你引用某个值而不获取其所有权。图4-6描绘了这一概念。
图4-6: &String s 指向 String s1 的图示
注意：使用 & 引用的相反操作是 解引用，这可以通过解引用操作符 * 来完成。我们将在第 8 章中看到解引用操作符的一些用法，并在第 15 章中讨论解引用的详细信息。
让我们更仔细地看看这里的函数调用:
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{s1}' is {len}."); } fn calculate_length(s: &String) -> usize { s.len() }
&s1 语法让我们创建一个引用，该引用指向s1的值，但不拥有它。因为不拥有它，所以当引用停止使用时，它所指向的值不会被释放。
同样，函数的签名使用 & 来表示参数 s 的类型是一个引用。让我们添加一些解释性的注释：
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{s1}' is {len}."); } fn calculate_length(s: &String) -> usize { // s is a reference to a String s.len() } // Here, s goes out of scope. But because it does not have ownership of what // it refers to, it is not dropped.
变量 s 有效的范围与任何函数参数的范围相同，但当 s 不再使用时，引用所指向的值不会被丢弃，因为 s 没有所有权。当函数的参数是引用而不是实际值时，我们不需要返回值以归还所有权，因为我们从未拥有过所有权。
我们将创建引用的行为称为借用。就像在现实生活中，如果一个人拥有某样东西，你可以从他们那里借用。当你用完后，必须归还。你并不拥有它。
所以，如果我们尝试修改我们借用的内容会发生什么？尝试清单 4-6 中的代码。剧透警告：它不起作用！
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}这里的错误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
8 | 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
|
7 | fn change(some_string: &mut String) {
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
正如变量默认是不可变的一样，引用也是如此。我们不允许修改我们有引用的东西。
可变引用
我们可以修复列表 4-6 中的代码，以允许我们修改借用的值，只需进行一些小的修改，使用 可变引用：
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 函数将修改其借用的值这一点非常明确。
可变引用有一个重要的限制：如果你有一个指向值的可变引用，那么你不能有其他任何指向该值的引用。尝试创建两个指向 s 的可变引用的代码将会失败：
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
}这里的错误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{}, {}", r1, r2);
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
这个错误表示此代码无效，因为我们不能同时多次借用 s 作为可变借用。第一次可变借用在 r1 中，并且必须持续到在 println! 中使用它为止，但在创建该可变引用和使用它之间，我们试图在 r2 中创建另一个可变引用，该引用借用与 r1 相同的数据。
防止同时对同一数据进行多个可变引用的限制允许进行变异，但以非常受控的方式进行。这是新 Rustaceans 会遇到困难的地方，因为大多数语言允许你在任何时候进行变异。拥有此限制的好处是 Rust 可以在编译时防止数据竞争。数据竞争类似于竞态条件，当以下三种行为发生时会出现：数据竞争
- 两个或更多的指针同时访问相同的数据。
- 至少有一个指针被用于写入数据。
- 没有使用任何机制来同步对数据的访问。
数据竞争会导致未定义行为，并且在运行时尝试跟踪和修复它们时可能会非常困难；Rust 通过拒绝编译存在数据竞争的代码来防止这个问题！
正如往常，我们可以使用大括号来创建一个新的作用域，允许有多个可变引用，只是不能 同时 存在：
fn main() { let mut s = String::from("hello"); { let r1 = &mut s; } // r1 goes out of scope here, so we can make a new reference with no problems. let r2 = &mut s; }
Rust 强制执行类似的规则，用于组合可变和不可变引用。 这段代码会导致错误：
fn main() {
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);
}这里的错误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{}, {}, and {}", r1, r2, r3);
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
呼！我们也不能在拥有一个不可变引用的同时拥有一个可变引用到同一个值。
不可变引用的用户不希望值突然发生变化！然而，允许多个不可变引用，因为只是读取数据的人没有能力影响其他人的数据读取。
请注意，引用的作用域从其被引入的地方开始，一直持续到最后一次使用该引用的地方。例如，这段代码可以编译，因为最后一次使用不可变引用，即println!，发生在可变引用被引入之前：
fn main() { 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 编译器在早期（编译时而不是运行时）指出一个潜在的错误，并准确地显示问题所在。然后你就不必追踪为什么你的数据不是你认为的样子。
悬垂引用
在具有指针的语言中，很容易错误地创建一个悬空指针——一个引用了可能已被分配给其他人的内存位置的指针——通过释放某些内存同时保留对该内存的指针。相比之下，在 Rust 中，编译器保证引用永远不会是悬空引用：如果你对某些数据有引用，编译器将确保该数据不会在引用数据之前超出作用域。
让我们尝试创建一个悬垂引用，看看 Rust 如何通过编译时错误来防止它们：let's try to create a dangling reference to see how Rust prevents them with a compile-time error:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}这里的错误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | 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`
|
5 | fn dangle() -> &'static String {
| +++++++
help: instead, you are more likely to want to return an owned value
|
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
|
error[E0515]: cannot return reference to local variable `s`
--> src/main.rs:8:5
|
8 | &s
| ^^ returns a reference to data owned by the current function
Some errors have detailed explanations: E0106, E0515.
For more information about an error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 2 previous errors
这个错误消息提到了一个我们尚未涉及的功能：生命周期。我们将在第 10 章详细讨论生命周期。但是，如果你忽略有关生命周期的部分，消息确实包含了为什么这段代码有问题的关键：
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
让我们更仔细地看看我们的 dangle 代码在每个阶段究竟发生了什么：
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle returns a reference to a String
let s = String::from("hello"); // s is a new String
&s // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
// Danger!因为 s 是在 dangle 内创建的，当 dangle 的代码执行完毕时，s 将会被释放。但我们试图返回一个指向它的引用。这意味着这个引用将指向一个无效的 String。这可不好！Rust 不会让我们这样做。
这里的解决方案是直接返回 String：
fn main() { let string = no_dangle(); } fn no_dangle() -> String { let s = String::from("hello"); s }
这没有任何问题。所有权被移出，但没有任何内容被释放。
引用的规则
让我们回顾一下我们讨论过的关于引用的内容：
- 在任何时候，你可以有要么一个可变引用或者任意数量的不可变引用。
- 引用必须始终有效。
接下来，我们将研究一种不同的引用类型：切片。