如何在十分鐘內掌握Rust引用？
近年來，Rust已經迅速成為最流行和增長最快的編程語言之一。谷歌和微軟等大型科技公司正在使用和投資它。它是一種允許帶有特殊約束的手動內存管理的語言，這在很大程度上確保了內存安全。
然而，Rust使用的約束(通常稱為借用檢查器)可能非常難以學習。嗯，如果你沒有正確學習的話。
這篇文章可以使你快速學習Rust中正確的引用概念。前提是你有一些Rust的基礎知識，比如結構體、函數和向量。
什么是引用？
引用是指在不顯式復制的情況下引用某些數據或變量的方法。Rust的引用與C和C++中的非混淆指針相同。在C和C++中，非混淆指針都是用restrict關鍵字定義的。在Rust中，引用采用的正是這種行為。但是，任何使引用相互命名別名的嘗試，無論是使用unsafe塊還是使用Rust的指針(這是另一個主題)，都將導致未定義的行為。不要這樣做。
在Rust中，有四種方法可以將變量“傳遞”或轉移到函數或作用域之外。
1，移動變量：默認情況下，Rust會在賦值或從函數返回值時移動值。移動意味著一旦變量被移動，就不能在之前的位置使用它。
2，傳遞不可變引用：不可變引用是一種從另一個作用域引用變量的方法，只要該引用不會超出它所引用的變量的作用域。在Rust中，這被稱為生命周期。可以有一個或多個對變量的不可變引用。
3，傳遞可變引用：可變引用是引用來自另一個作用域的變量的一種方式，適用于類似的生命周期規則。但是，一個變量一次只有一個可變引用。這意味著在任何給定時間，任何變量都只能通過單個引用進行修改。
4，傳遞副本：在Rust中，不同的類型可以實現Copy或Clone特征，這樣它們就可以隱式或顯式地復制。Copy和Clone之間的主要區別在于前者是一個字節一個字節的memcpy風格復制，而Clone是顯式實現的一個成員一個成員的復制，可以使用自定義邏輯。
規則
引用的第一個也是最重要的規則是只有一個可變引用或多個不可變引用。但有一個問題是，這在實踐中看起來如何？讓我們來看幾個例子，從下面這個開始：
fn main() {
let mut a = 6;
let b = &a;
let c = &mut a;
println!("{}", *c);
}上面的代碼實際上是有效的，你可能會認為同時存在不可變引用和可變引用。然而，需要注意的是，代碼只使用了c，沒有使用b下的不可變引用。由于這個原因，Rust的借用檢查器不會報錯。但是讓我們看看當我們開始使用b時會發生什么：
fn main() {
let mut a = 6;
let b = &a;
let c = &mut a;
println!("{}", *b);
}這會導致編譯失敗：
error[E0502]: cannot borrow `a` as mutable because it is also borrowed as immutable
--> src/main.rs:7:13
|
6 | let b = &a;
| -- immutable borrow occurs here
7 | let c = &mut a;
| ^^^^^^ mutable borrow occurs here
8 | println!("{}", *b);
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.b被println!借走了，這會導致不可變和可變引用不能同時存在的規則被打破。
接下來，讓我們看一個更復雜的例子：
fn main() {
let mut a = 6;
let mut b = &a;
let c = &mut b;
println!("{}", *c);
}乍一看，這看起來像是對同一個變量取了一個可變引用和一個不可變引用。然而，理解引用既是類型又是操作符是至關重要的。當使用引用操作符時，它接受與該操作符一起使用的變量的引用。
這意味著，c是對整數引用的可變引用。這個引用的Rust類型看起來像&mut&usize。在上面的代碼中，c可以被解引用并指向一個不同的&usize引用，這個引用會改變b，但不會改變a。如果我們試圖通過c來改變a，如下：
fn main() {
let mut a = 6;
let mut b = &a;
let c = &mut b;
**c += 1;
println!("{}", *c);
}會出現以下錯誤：
error[E0594]: cannot assign to `**c`, which is behind a `&` reference
--> src/main.rs:8:5
|
8 | **c += 1;
| ^^^^^^^^ cannot assign引用，類似于C/C++中的指針，可以形成任意長度的復合類型，這樣，&mut&mut&usize也可以作為Rust引用存在。與指針不同的是，引用的生命周期必須足夠長，否則，借用檢查器會讓你止步不前。
生命周期
在這里，我們可以探索各種引用的生命周期，并了解何時創建和銷毀引用(或者像Rust所說的“drop”)。下面的例子：
fn main() {
let mut a = 6;
let mut b = &a;
{
let c = 7;
b = &c;
}
println!("{}", *b);
}產生錯誤：
error[E0597]: `c` does not live long enough
--> src/main.rs:9:13
|
8 | let c = 7;
| - binding `c` declared here
9 | b = &c;
| ^^ borrowed value does not live long enough
10 | }
| - `c` dropped here while still borrowed
11 | println!("{}", *b);
| -- borrow later used here在內部作用域中，b被改變為保存對c的引用。但是一旦內部作用域結束，c就不存在了。因此，在這種情況下，引用比它引用的變量生命周期更長，所以產生了錯誤。
同樣的規則不適用于副本，因為副本是彼此獨立存在的。如果采用相同的代碼來刪除引用的使用：
fn main() {
let mut a = 6;
let mut b = a;
{
let c = 7;
b = c;
}
println!("{}", b);
}代碼編譯沒有錯誤。由于整數相對較小，因此通常可以復制它們。然而，更大的類型使用引用計數或按引用傳遞，以避免性能下降。
基于作用域的生命周期規則也適用于在較大的類實例中獲取引用。
struct Container(Vec<u64>);
impl Container {
fn get(&self, index:usize) -> &u64 {
&self.0[index]
}
}在上面的代碼中，get返回對vector中的引用，但是vector的生命周期必須比返回的引用長。如果我們應用同樣的邏輯，
fn main() {
let m = Container(vec![1, 2, 3]);
let mut the_ref = m.get(0);
{
let d = Container(vec![1, 2, 3]);
the_ref = d.get(1);
}
println!("{}", the_ref);
}此代碼也無法編譯，并出現類似的錯誤
error[E0597]: `d` does not live long enough
--> src/main.rs:15:19
|
14 | let d = Container(vec![1, 2, 3]);
| - binding `d` declared here
15 | the_ref = d.get(1);
| ^ borrowed value does not live long enough
16 | }
| - `d` dropped here while still borrowed
17 | println!("{}", the_ref);
| ------- borrow later used here當某些東西在Rust中被刪除時，所有實現Drop特性的成員也將被刪除。
迭代和引用
當在迭代或循環中使用引用時，有幾種獨特的行為。如果迭代也是不可變的，則對集合類型的迭代，通常使循環充當該集合上的不可變借用的作用域。以下代碼為例：
fn main() {
let mut a = vec![1, 2, 3, 4];
for elem in a.iter() {
if *elem % 2 == 0 {
a.remove(*elem);
}
}
}會導致編譯錯誤：
error[E0502]: cannot borrow `a` as mutable because it is also borrowed as immutable
--> src/main.rs:8:13
|
6 | for elem in a.iter() {
| --------
| |
| immutable borrow occurs here
| immutable borrow later used here
7 | if *elem % 2 == 0 {
8 | a.remove(*elem);
| ^^^^^^^^^^^^^^^ mutable borrow occurs hereRust遵循這樣的規則：對某種類型的不可變迭代是一系列不可變借用，因此，不能在該迭代期間可變地借用相同的類型。
現在，你可能會認為這段特定代碼的解決方案是對其進行可變迭代。然而，這仍然是不正確的！如果將iter()改為iter_mut()：
fn main() {
let mut a = vec![1, 2, 3, 4];
for elem in a.iter_mut() {
if *elem % 2 == 0 {
a.remove(*elem);
}
}
}會出現以下錯誤：
error[E0499]: cannot borrow `a` as mutable more than once at a time
--> src/main.rs:8:13
|
6 | for elem in a.iter_mut() {
| ------------
| |
| first mutable borrow occurs here
| first borrow later used here
7 | if *elem % 2 == 0 {
8 | a.remove(*elem);
| ^ second mutable borrow occurs here讓我們回顧一下引用規則，一個或多個不可變引用，或者僅僅是一個可變引用。在本例中，我們創建了兩個可變引用，借用檢查器將拒絕它們。但是這個規則實際上是有意義的，它可以保護免受內存損壞錯誤的影響。
根據集合的內部實現，修改集合類型會使現有迭代器失效。這可能是因為集合處理的內存塊可能被分配或釋放，從而導致懸空指針，但是可變引用規則有效地防止了這種情況。
