Rust 的最主要光芒： 內(nèi)存安全 。

實現(xiàn)方式： 所有權系統(tǒng)。

寫在前面的序言

因為我們這里實際講述的內(nèi)容是關于 內(nèi)存安全的，所以我們最好先復習一下內(nèi)存的知識。

然后我們，需要理解的就只有所有權概念，以及為了開發(fā)便利，進一步引出的引用借用概念。

永遠的基礎，內(nèi)存管理

內(nèi)存作為存儲程序運行時數(shù)據(jù)的地方，是任何地方都避不開的。除非發(fā)展到量子計算，脫離了傳統(tǒng)的二進制計算架構。

在這里先說明一下內(nèi)存討論的主體顆粒度。我們將著眼于 棧（stack） 和 堆 （heap）。重點明晰的是保存的位置是這兩者中的哪一種。

棧

棧按照順序存儲值并以相反順序取出值，這也被稱作后進先出。想象一下一疊盤子：當增加更多盤子時，把它們放在盤子堆的頂部，當需要盤子時，再從頂部拿走。不能從中間也不能從底部增加或拿走盤子！

增加數(shù)據(jù)叫做進棧，移出數(shù)據(jù)則叫做出棧。

因為上述的實現(xiàn)方式，棧中的所有數(shù)據(jù)都必須占用已知且固定大小的內(nèi)存空間，假設數(shù)據(jù)大小是未知的，那么在取出數(shù)據(jù)時，你將無法取到你想要的數(shù)據(jù)。

堆

與棧不同，對于大小未知或者可能變化的數(shù)據(jù)，我們需要將它存儲在堆上。

當向堆上放入數(shù)據(jù)時，需要請求一定大小的內(nèi)存空間。操作系統(tǒng)在堆的某處找到一塊足夠大的空位，把它標記為已使用，并返回一個表示該位置地址的指針, 該過程被稱為在堆上分配內(nèi)存，有時簡稱為 “分配”(allocating)。

接著，該指針會被推入棧中，因為指針的大小是已知且固定的，在后續(xù)使用過程中，你將通過棧中的指針，來獲取數(shù)據(jù)在堆上的實際內(nèi)存位置，進而訪問該數(shù)據(jù)。

由上可知，堆是一種缺乏組織的數(shù)據(jù)結(jié)構。想象一下去餐館就座吃飯: 進入餐館，告知服務員有幾個人，然后服務員找到一個夠大的空桌子（堆上分配的內(nèi)存空間）并領你們過去。如果有人來遲了，他們也可以通過桌號（棧上的指針）來找到你們坐在哪。

性能區(qū)別

寫入方面：入棧比在堆上分配內(nèi)存要快，因為入棧時操作系統(tǒng)無需分配新的空間，只需要將新數(shù)據(jù)放入棧頂即可。相比之下，在堆上分配內(nèi)存則需要更多的工作，這是因為操作系統(tǒng)必須首先找到一塊足夠存放數(shù)據(jù)的內(nèi)存空間，接著做一些記錄為下一次分配做準備。

讀取方面：得益于 CPU 高速緩存，使得處理器可以減少對內(nèi)存的訪問，高速緩存和內(nèi)存的訪問速度差異在 10 倍以上！棧數(shù)據(jù)往往可以直接存儲在 CPU 高速緩存中，而堆數(shù)據(jù)只能存儲在內(nèi)存中。訪問堆上的數(shù)據(jù)比訪問棧上的數(shù)據(jù)慢，因為必須先訪問棧再通過棧上的指針來訪問內(nèi)存。

因此，處理器處理分配在棧上數(shù)據(jù)會比在堆上的數(shù)據(jù)更加高效。

所有權和堆棧

所謂的所有權，他存在的意義就是通過某種邏輯實現(xiàn)對堆上數(shù)據(jù)的管理。

接下來，讓我們詳細的介紹所有權對內(nèi)存管理的具體邏輯。

所有權原則

讓我們首先明確規(guī)則，再去詳細了解內(nèi)涵

1. Rust 中每一個值都被一個變量所擁有，該變量被稱為值的所有者
2. 一個值同時只能被一個變量所擁有，或者說一個值只能擁有一個所有者
3. 當所有者(變量)離開作用域范圍時，這個值將被丟棄(drop)

那么什么是 變量的作用域呢？

變量的作用域

同 c++ 類似，作用域是變量合法有效的范圍，
從變量的創(chuàng)建開始有效，止于它離開作用域為止。代碼說明如下：

{                   // s 在這里無效，它尚未聲明
    let s = "zry";  // s 在這里無效，它尚未聲明
    // code 
    ....
}                   // s 在這里無效，它尚未聲明

堆上數(shù)據(jù)和 棧上數(shù)據(jù)

在這里我們會通過 代碼來介紹在 rust 中 什么數(shù)據(jù)會在堆上，什么數(shù)據(jù)會在棧上。

我們使用 String類型進行介紹。

先繼續(xù)使用上面的代碼 let s = "zry" 這里的s 是被編譯器 硬編碼進程序里的字符串值，類型是 &str。但是它有一些缺陷。如下：
- 字符串字面值是不可變的，因為被硬編碼到程序代碼中。
- 并非所有字符串的值都能在編寫代碼時得知。
- 例如：獲取用戶輸入的數(shù)據(jù)時，編譯器肯定是不能在編譯時預先知道這部分內(nèi)容應當怎么寫的。
所以，Rust 提供了 動態(tài)字符串類型：String。這個類型被分配到堆上，當出現(xiàn)需要再擴充空間或者縮小時，都可以很方便實現(xiàn)。

具體的創(chuàng)建方式如下：

let s = String::from("zry");
// `::` 是一種調(diào)用操作符，這里表示調(diào)用 `String` 中的 `from` 方法，因為 `String` 存儲在堆上是動態(tài)的，你可以這樣修改它：

s.push_str("say hello, world!"); // push_str() 在字符串后追加字面值 println!("{}", s); // 將打印 `zry say hello, world!`

到此，我們知道怎樣在堆上創(chuàng)建數(shù)據(jù)（String）和棧上創(chuàng)建數(shù)據(jù) （&str）

接下來，我們將根據(jù)這兩點 展開講述 所有權的交互。

所有權的交互

所有權的交互分為三種：

• 轉(zhuǎn)移所有權，A的給了B，B能用，A不能用
• 克隆所有權（深拷貝）：B抄了A的，多了一份數(shù)據(jù)，A和B各自使用各自的。
• 拷貝所有權（淺拷貝）：B知道A有，共用一份數(shù)據(jù)，A和B使用同一份內(nèi)容。

所有權是對堆上數(shù)據(jù)的管理權限。先看棧上數(shù)據(jù)的代碼：

let x = 5;
let y = x;

代碼背后的邏輯很簡單, 將 5 綁定到變量 x；接著拷貝 x 的值賦給 y，最終 x 和 y 都等于 5，因為整數(shù)是 Rust 基本數(shù)據(jù)類型，是固定大小的簡單值，因此這兩個值都是通過自動拷貝的方式來賦值的，都被存在棧中，完全無需在堆上分配內(nèi)存

我們在前面就討論過，拷貝是一個應當重視的行為，那么：這里使用拷貝有什么問題嗎？

實際上，我們重視拷貝的原因是因為拷貝需要增加空間，保護數(shù)據(jù)，消耗時間。在規(guī)模變得足夠大的時候，就會造成性能浪費。

而這種棧上操作的數(shù)據(jù)足夠的簡單，拷貝這個行為也只是需要復制一個整數(shù)大?。?code>i32，4個字節(jié)）的內(nèi)存即可，因此在這種情況下，拷貝的速度遠快于堆上創(chuàng)建內(nèi)存，而內(nèi)容也足夠小，不會造成性能浪費。

實際上 Rust 的基本類型都是通過自動拷貝的方式來賦值的

接下來詳細介紹：

轉(zhuǎn)移所有權

從基礎類型賦值之后，我們使用String類型完成這一節(jié)的演示。
首先代碼如下：

let s1 = String::from("zry");
let s2 = s1;

這里 String并不是基礎類型，rust只對基礎類型進行自動拷貝

String類型數(shù)據(jù)是存放在堆上的，它本身是一個復合類型，你可以把它簡單抽象是一個結(jié)構體來方便理解。它提供了三部分：存儲在棧中的堆指針、字符串長度、字符串容量共同組成，其中的堆指針是根本，字符串長度、字符串容量是為了性能考量的輔助優(yōu)化。

• 堆指針指向了真實存儲字符串內(nèi)容的堆內(nèi)存，
• 字符串容量是堆內(nèi)存分配空間的大小
• 字符串長度是目前已經(jīng)使用的大小。

回到代碼中來，繼續(xù)討論 let s2 = s1;的這一步：
分成兩種情況討論：

1. 拷貝 String 和存儲在堆上的字節(jié)數(shù)組 如果該語句是拷貝所有數(shù)據(jù)(深拷貝)，那么無論是 String 本身還是底層的堆上數(shù)據(jù)，都會被全部拷貝，這對于性能而言會造成非常大的影響

2. 只拷貝 String 本身 這樣的拷貝非?？?，因為在 64 位機器上就拷貝了 8字節(jié)的指針、8字節(jié)的長度、8字節(jié)的容量，總計 24 字節(jié)，但是帶來了新的問題，還記得我們之前提到的所有權規(guī)則吧？其中有一條就是：一個值只允許有一個所有者，而現(xiàn)在這個值（堆上的真實字符串數(shù)據(jù)）有了兩個所有者：s1 和 s2。

好吧，就假定一個值可以擁有兩個所有者，會發(fā)生什么呢？

當變量離開作用域后，Rust 會自動調(diào)用 drop 函數(shù)并清理變量的堆內(nèi)存。不過由于兩個 String 變量指向了同一位置。這就有了一個問題：當 s1 和 s2 離開作用域，它們都會嘗試釋放相同的內(nèi)存。這是一個叫做 二次釋放（double free） 的錯誤，也是之前提到過的內(nèi)存安全性 BUG 之一。兩次釋放（相同）內(nèi)存會導致內(nèi)存污染，它可能會導致潛在的安全漏洞。

因此，Rust 這樣解決問題：當 s1 賦予 s2 后，Rust 認為 s1 不再有效，因此也無需在 s1 離開作用域后 drop 任何東西，這就是把所有權從 s1 轉(zhuǎn)移給了 s2，s1 在被賦予 s2 后就馬上失效了。

再來看看，在所有權轉(zhuǎn)移后再來使用舊的所有者，會發(fā)生什么：

let s1 = String::from("zry");
let s2 = s1;

println!("{} sqy hello world!", s1);

由于 Rust 禁止你使用無效的引用，你會看到以下的錯誤：

error[E0382]: use of moved value: `s1`
 --> src/main.rs:5:28
  |
3 |     let s2 = s1;
  |         -- value moved here
4 |
5 |     println!("{}, world!", s1);
  |                            ^^ value used here after move
  |
  = note: move occurs because `s1` has type `std::string::String`, which does
  not implement the `Copy` trait

現(xiàn)在再回頭看看之前的規(guī)則，相信大家已經(jīng)有了更深刻的理解：

1. Rust 中每一個值都被一個變量所擁有，該變量被稱為值的所有者
2. 一個值同時只能被一個變量所擁有，或者說一個值只能擁有一個所有者
3. 當所有者(變量)離開作用域范圍時，這個值將被丟棄(drop)

如果你在其他語言中聽說過術語 淺拷貝(shallow copy) 和 深拷貝(deep copy)，那么拷貝指針、長度和容量而不拷貝數(shù)據(jù)聽起來就像淺拷貝，但是又因為 Rust 同時使第一個變量 s1 無效了，因此這個操作被稱為 移動(move)，而不是淺拷貝。上面的例子可以解讀為 s1 被移動到了 s2 中。那么具體發(fā)生了什么，用一張圖簡單說明：
![[Pasted image 20230815214121.png]]

這樣就解決了我們之前的問題，s1 不再指向任何數(shù)據(jù)，只有 s2 是有效的，當 s2 離開作用域，它就會釋放內(nèi)存。 到此為止，我們也清楚了為什么 Rust 稱呼 let a = b 為變量綁定。
綁定的是變量中記錄的指針和數(shù)據(jù)實際地址這兩者。

擴展：引用的所有權

再來看一段代碼:

fn main() {
    let x: &str = "hello, world";
    let y = x;
    println!("{},{}",x,y);
}

這段代碼，大家覺得會否報錯？如果參考之前的 String 所有權轉(zhuǎn)移的例子，那這段代碼也應該報錯才是，但是實際上呢？

這段代碼和之前的 String 有一個本質(zhì)上的區(qū)別：在 String 的例子中 s1 持有了通過String::from("hello") 創(chuàng)建的值的所有權，而這個例子中，x 只是引用了存儲在二進制中的字符串 "hello, world"，并沒有持有所有權。

因此 let y = x 中，僅僅是對該引用進行了拷貝，此時 y 和 x 都引用了同一個字符串。如果還不理解也沒關系，當學習了下一章節(jié) “引用與借用” 后，大家自然而言就會理解。

克隆所有權

Rust 中是支持深拷貝的，被稱之為 克隆所有權。

• 但是要注意：Rust 永遠不會自動創(chuàng)建數(shù)據(jù)的深拷貝。
• 所以，如果你發(fā)現(xiàn)rust 在進行自動的復制，那么其是淺拷貝（棧上數(shù)據(jù)的賦值 let x =1; let i=x;），或者是轉(zhuǎn)移所有權（let s::String = “String”; let y = s;）。

克隆所有權的具體方式是使用 clone()這個關鍵字。示例如下：

let s1 = String::from("zry");
let s2 = s1.clone();

println!("{} > {} ",s1,s2);

當讓，我們可以豐富擴展一下，rust 有一個叫做 Ok ERR 的東西，可以這樣方便測試：

// 定義一個函數(shù) test_string，返回一個 Result 類型，
// 其中 Ok 部分包含一個字符串，Err 部分包含一個 &'static str 類型的錯誤信息
fn test_string() -> Result<String, &'static str> { 
    let s = String::from("hello world"); //創(chuàng)建一個包含 "hello world" 的 String 類型變量 s
    let y = s.clone(); //深拷貝 s 的字符串堆。
    println!("{} > {}", s,y);
    Ok(y) //將變量s y 作為 Ok 部分的返回值
}

fn main() { //主函數(shù)
    println!("Hello, world!"); //打印 "Hello, world!"
    match test_string() { //使用 match 匹配 test_string 函數(shù)的返回值
        Ok(z) => println!("{}", z), //如果返回的是 Ok，則將字符串 z 打印出來
        Err(e) => eprintln!("Error: {}", e), //如果返回的是 Err，則將錯誤信息 e 打印出來
    }
}

執(zhí)行結(jié)果：

PS ...\ZryCode\CODE\Rust\file23_08_21> cargo run 
   Compiling file23_08_21 v0.1.0 (...\ZryCode\CODE\Rust\file23_08_21)
    Finished dev [unoptimized + debuginfo] target(s) in 0.60s
     Running `target\debug\file23_08_21.exe`
Hello, world!
hello world > hello world
hello world

• 注意事項：深拷貝性能消耗是要大于其他方式的。因此，對于熱點路徑（執(zhí)行比較頻繁的代碼），使用 clone會極大的降低程序性能。

拷貝所有權

在上面我們說到了拷貝所有權，這里詳細介紹。

• 拷貝所有權，是指淺拷貝。
• 淺拷貝只發(fā)生在棧上。因此性能很高

通過代碼介紹：

let x = 5;
let y = x;
println!("x = {} ,y = {}",x,y);

上面的代碼中，我們并沒有進行 clone，如果按照之前的說法：所有權改變了以后，原有變量不再使用，這里x，應當不能使用了，但是實際運行之后，依舊打印出了x的內(nèi)容。
這里引出 rust 中的 一個特征：Copy

整型這樣的基本類型是在編譯時已知大小的，會被存儲在棧上。Rust 通過copy這樣的特征來保證擁有這樣特征的類型，可以實現(xiàn)：一個舊的變量在被賦值給其他變量后任然可以使用。

哪些類型可 Copy？

• 任何基本類型的組合都可以Copy，
• 不需要分配內(nèi)存或某種形式資源的類型是可以Copy的。

如下是一些 Copy 的類型：

• 所有整數(shù)類型，比如 u32
• 布爾類型，bool，它的值是 true 和 false
• 所有浮點數(shù)類型，比如 f64
• 字符類型，char
• 元組，當且僅當其包含的類型也都是 Copy 的時候。比如，(i32, i32) 是 Copy 的，但 (i32, String) 就不是
• 不可變引用 &T ，例如 擴展：引用的所有權 中的例子，但是注意: 可變引用 &mut T 是不可以 Copy的

函數(shù)傳值與返回

既然我們前面說到了：賦值是會改變所有權的。那么自然會聊到一個點：函數(shù)傳值。

在將值傳遞給函數(shù)時，一樣會發(fā)生 移動 或者 復制 ，就像賦值一樣。具體可以看下面的代碼：

// 定義一個函數(shù) test_string，返回一個 Result 類型，
// 其中 Ok 部分包含一個字符串，Err 部分包含一個 &'static str 類型的錯誤信息
fn test_string() -> Result<String, &'static str> {
    let s = String::from("hello world"); //創(chuàng)建一個包含 "hello world" 的 String 類型變量 s
    let y = s.clone(); //深拷貝 s 的字符串堆。
    println!("{} > {}", s, y);
    Ok(y) //將變量s y 作為 Ok 部分的返回值
}

fn test_string_2() {
    let x = 5;
    let y = x;
    println!("x = {} ,y = {}", x, y);
}

fn takes_ownership(some_string: String) {
    // some_string 進入作用域
    println!("{}", some_string);
} // 這里，some_string 移出作用域并調(diào)用 `drop` 方法。占用的內(nèi)存被釋放

fn makes_copy(some_integer: i32) {
    // some_integer 進入作用域
    println!("{}", some_integer);
} // 這里，some_integer 移出作用域。不會有特殊操作

fn main() {
    //主函數(shù)
    println!("Hello, world!"); //打印 "Hello, world!"
    match test_string() {
        //使用 match 匹配 test_string 函數(shù)的返回值
        Ok(z) => println!("{}", z), //如果返回的是 Ok，則將字符串 z 打印出來
        Err(e) => eprintln!("Error: {}", e), //如果返回的是 Err，則將錯誤信息 e 打印出來
    }
    test_string_2();
    let s = String::from("hello"); // s 進入作用域

    //-------------------------------------
    takes_ownership(s); // s 的值移動到函數(shù)里 ...
                        // ... 所以到這里不再有效

    let x = 5; // x 進入作用域

    makes_copy(x); // x 應該移動函數(shù)里，
                   // 但 i32 是 Copy 的，所以在后面可繼續(xù)使用 x
} // 這里, x 先移出了作用域，然后是 s。但因為 s 的值已被移走，
  // 所以不會有特殊操作

運行后如下結(jié)果：

PS ...\ZryCode\CODE\Rust\file23_08_21> cargo run
   Compiling file23_08_21 v0.1.0 (...\ZryCode\CODE\Rust\file23_08_21)
    Finished dev [unoptimized + debuginfo] target(s) in 1.41s
     Running `target\debug\file23_08_21.exe`
Hello, world!
hello world > hello world
hello world
x = 5 ,y = 5
hello
5

同樣的，函數(shù)返回值也有所有權，例如:

// 定義一個函數(shù) test_string，返回一個 Result 類型，
// 其中 Ok 部分包含一個字符串，Err 部分包含一個 &'static str 類型的錯誤信息
fn test_string() -> Result<String, &'static str> {
    let s = String::from("hello world"); //創(chuàng)建一個包含 "hello world" 的 String 類型變量 s
    let y = s.clone(); //深拷貝 s 的字符串堆。
    println!("{} > {}", s, y);
    Ok(y) //將變量s y 作為 Ok 部分的返回值
}

fn test_string_2() {
    let x = 5;
    let y = x;
    println!("x = {} ,y = {}", x, y);
}

fn takes_ownership(some_string: String) {
    // some_string 進入作用域
    println!("{}", some_string);
} // 這里，some_string 移出作用域并調(diào)用 `drop` 方法。占用的內(nèi)存被釋放

fn makes_copy(some_integer: i32) {
    // some_integer 進入作用域
    println!("{}", some_integer);
} // 這里，some_integer 移出作用域。不會有特殊操作

fn main() {
    //主函數(shù)
    println!("Hello, world!"); //打印 "Hello, world!"
    match test_string() {
        //使用 match 匹配 test_string 函數(shù)的返回值
        Ok(z) => println!("{}", z), //如果返回的是 Ok，則將字符串 z 打印出來
        Err(e) => eprintln!("Error: {}", e), //如果返回的是 Err，則將錯誤信息 e 打印出來
    }
    test_string_2();
    let s = String::from("hello"); // s 進入作用域

    //-------------------------------------
    takes_ownership(s); // s 的值移動到函數(shù)里 ...
                        // ... 所以到這里不再有效
    println!("S == {}",s);
    let x = 5; // x 進入作用域

    makes_copy(x); // x 應該移動函數(shù)里，
                   // 但 i32 是 Copy 的，所以在后面可繼續(xù)使用 x

    let s1 = gives_ownership_2(); // gives_ownership_2 將返回值
                                  // 移給 s1

    let s2 = String::from("hello"); // s2 進入作用域

    let s3 = takes_and_gives_back_2(s2); // s2 被移動到
                                         // takes_and_gives_back_2 中,
                                         // 它也將返回值移給 s3
} // 這里, s3 移出作用域并被丟棄。s2 也移出作用域，但已被移走，
  // 所以什么也不會發(fā)生。s1 移出作用域并被丟棄

fn gives_ownership_2() -> String {
    // gives_ownership_2 將返回值移動給
    // 調(diào)用它的函數(shù)

    let some_string = String::from("hello"); // some_string 進入作用域.

    some_string // 返回 some_string 并移出給調(diào)用的函數(shù)
}

// takes_and_gives_back_2 將傳入字符串并返回該值
fn takes_and_gives_back_2(a_string: String) -> String {
    // a_string 進入作用域

    a_string // 返回 a_string 并移出給調(diào)用的函數(shù)
}

其中如果在變量傳入函數(shù)后，再次使用變量，就會報錯如下：

error[E0382]: borrow of moved value: `s`
  --> src\main.rs:51:24
   |
46 |     let s = String::from("hello"); // s 進入作用域
   |         - move occurs because `s` has type `String`, which does not implement the `Copy` trait
...
49 |     takes_ownership(s); // s 的值移動到函數(shù)里 ...
   |                     - value moved here
50 |                         // ... 所以到這里不再有效
51 |     println!("S == {}",s);
   |                        ^ value borrowed here after move
   |

很明顯，這樣的方式不利于我們開發(fā)時使用。
因此 ，我們繼續(xù)介紹 引用和借用。 所有權很強大，避免了內(nèi)存的不安全性，但是也帶來了一個新麻煩： 總是把一個值傳來傳去來使用它。 傳入一個函數(shù)，很可能還要從該函數(shù)傳出去，結(jié)果就是語言表達變得非常啰嗦，幸運的是，Rust 提供了新功能解決這個問題。

貼一個體驗不錯的學習鏈接恰飯：學習鏈接文章來源地址http://www.zghlxwxcb.cn/news/detail-664504.html

到了這里，關于Rust 基礎入門 —— 2.3.所有權和借用的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！