Rust 基础入门 —— 2.3.所有权和借用 （二）
引用和借用
我们之前说了很多，总结一句话：所有权，让代码可以免去内存回收的问题，但不方便开发。解决方式，就是引用和借用。
这里我们具体介绍这个概念。
是什么？
引用和借用是一个事情，表示的是通过语法，告诉 编译器，不要改动所有权。只是一个代称。你可以叫它引用，也可以叫他借用。是一回事情。当然官方的说法是：获取变量的引用，称之为借用（borrowing）
为什么的问题，已经在开头说明了。便于开发。
怎么做？
这里我们分四块介绍：
- 引用和解引用
- 不可变引用
- 可变引用
- 悬垂引用
引用和解引用
废话不说，上代码
let z = String::from("hello word");
let r = &z; // 这里就是引用了
println!("{}，{}, {}, {}",z,r,*r,&z);
assert_eq!("hello word", z.to_string());// 这两者写法都可以
assert_eq!("hello word", z);// 这两者写法都可以
assert_eq!("hello word", *r);
上面的代码中 z 中存放了原始的数据，r是 z的一个引用。可以断言 z 等于 hello word，但是想要对 r的值进行断言，就必须使用*r来解出 引用所指向的值（也就是解引用）。一旦解引用了r就可以访问r的值，
那么既然 对 z可以使用两种方式，那么解引用的方式呢？
PS ...\ZryCode\CODE\Rust\file23_08_21> cargo run
Compiling file23_08_21 v0.1.0 (...\ZryCode\CODE\Rust\file23_08_21)
error[E0277]: can't compare `&str` with `str`
--> src\main.rs:69:5
|
69 | assert_eq!("hello word", *r.to_string());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `&str == str`
|
= help: the trait `PartialEq<str>` is not implemented for `&str`
= help: the following other types implement trait `PartialEq<Rhs>`:
<&'a str as PartialEq<OsString>>
<&'a str as PartialEq<String>>
<&'b str as PartialEq<Cow<'a, str>>>
<str as PartialEq<Cow<'a, str>>>
<str as PartialEq<OsStr>>
<str as PartialEq<OsString>>
<str as PartialEq<String>>
<str as PartialEq>
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0277`.
error: could not compile `file23_08_21` due to previous error
另外补充：
let s = String::from("hello");
let s1 = &s;
let s2 = &s1;
let s3 = &s2;
println!("{}", s3.len());
println!("{}", *s3); // 可以正常展示 hello
println!("{}", ***s3); // 依旧可以正常展示 hello
所以，我们可以认为 解引用不关心引用了几次，会一直找到原始数据源为止。
在介绍了引用和解引用之后，我们只是了解到了简单的使用，具体一点的，引用分为三种
不可变引用
就是说我的目的只是传值，不想改变值得内容。
用途：多用于 函数传值，
核心思想：我拿来借一下就好，我不想管理数据。
具体代码：
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()
}
注意到两点：
- 无需像之前一样：先通过函数参数传入所有权，然后再通过函数返回来传出所有权，代码更加简洁
calculate_length的参数s类型从String变为&String
这里，& 符号即是引用，它们允许你使用值，但是不获取所有权，如图所示：
![[Pasted image 20230821170647.png]]
通过 &s1 语法，我们创建了一个指向 s1 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。
同理，函数 calculate_length 使用 & 来表明参数 s 的类型是一个引用：
fn calculate_length(s: &String) -> usize { // s 是对 String 的引用 s.len() } // 这里，s 离开了作用域。但因为它并不拥有引用值的所有权， // 所以什么也不会发生
可变引用
我们在c++ 中形参不单是 const 还要 可变 形参， 在rust中也有。我们称之为可变引用。
在rust中依然使用得是mut 关键字。
具体代码如下：
fn main(){
let mut zry = String::from("hello");
change(&mut zry);
println!("{}",zry);
}
fn change(some_string: &mut String)
{
some_string.push_str(" word");
}
首先，声明 zry 是可变类型，其次创建一个可变的引用 &mut zry 和接受可变引用参数 some_string: &mut String 的函数。
重点一
- 可变引用同时只能存在一个：你可以认为——当我想要改变一个对象时，我不希望别人也可以改变它。 rust 从编译器层面上保证了这个事情。
具体来讲：
fn main(){
let mut zry = String::from("hello");
change(&mut zry);
println!("{}",zry);
let r1 = &mut zry;
let r2 = &mut zry;
println("{} {}",r1, r2);
}
fn change(some_string: &mut String)
{
some_string.push_str(" word");
}
这样的代码会出现问题：因为它 违反了上述的：可变引用同时只能存在一个的原则。
报错如下：
error[E0499]: cannot borrow `zry` as mutable more than once at a time
--> src\main.rs:107:14
|
106 | let r1 = &mut zry;
| -------- first mutable borrow occurs here
107 | let r2 = &mut zry;
| ^^^^^^^^ second mutable borrow occurs here
108 | println!("{} {}",r1, r2);
| -- first borrow later used here
这段代码出错的原因在于，第一个可变借用 r1 必须要持续到最后一次使用的位置 println!，在 r1 创建和最后一次使用之间，我们又尝试创建第二个可变借用 r2。
对于新手来说，这个特性绝对是一大拦路虎，也是新人们谈之色变的编译器 borrow checker 特性之一，不过各行各业都一样，限制往往是出于安全的考虑，Rust 也一样。
这种限制的好处就是使 Rust 在编译期就避免数据竞争，数据竞争可由以下行为造成：
- 两个或更多的指针同时访问同一数据
- 至少有一个指针被用来写入数据
- 没有同步数据访问的机制
数据竞争会导致未定义行为，这种行为很可能超出我们的预期，难以在运行时追踪，并且难以诊断和修复。而 Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！
很多时候，大括号可以帮我们解决一些编译不通过的问题，通过手动限制变量的作用域：
fn main(){
let mut zry = String::from("hello");
change(&mut zry);
println!("{}",zry);
{
let r1 = &mut zry;
}
let r2 = &mut zry;
println("{}", r2);
}
fn change(some_string: &mut String)
{
some_string.push_str(" word");
}
这样就好了
重点二
- 可变引用与不可变引用不能同时存在 —— 其本质是指：你又想一个东西不变，又想一个东西能让你变，这件事本身就是矛盾的。
error[E0502]: cannot borrow `zry` as immutable because it is also borrowed as mutable
--> src\main.rs:110:14
|
109 | let r2 = &mut zry;
| -------- mutable borrow occurs here
110 | let r3 = &zry;
| ^^^^ immutable borrow occurs here
111 | println!("{} ", r2);
| -- mutable borrow later used here
多个不可变借用被允许是因为没有人会去试图修改数据，每个人都只读这一份数据而不做修改，因此不用担心数据被污染
补充说明：
- 注意，引用的作用域
s从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同，变量的作用域从创建持续到某一个花括号}
悬垂引用
悬垂引用也叫做悬垂指针，意思为指针指向某个值后，这个值被释放掉了，而指针仍然存在，其指向的内存可能不存在任何值或已被其它变量重新使用。在 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: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
|
5 | fn dangle() -> &'static String {
| ~~~~~~~~
错误信息引用了一个我们还未介绍的功能：生命周期(lifetimes)。不过，即使你不理解生命周期，也可以通过错误信息知道这段代码错误的关键信息：
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 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放，但是此时我们又尝试去返回它的引用。这意味着这个引用会指向一个无效的 String，这可不对！
其中一个很好的解决方法是直接返回 String：
fn no_dangle() -> String {
let s = String::from("hello");
s
}
这样就没有任何错误了，最终 String 的 所有权被转移给外面的调用者。
总结：
- 同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用
- 引用必须总是有效的