Rust 中的複製、所有權與智慧型指標

Rust 的所有權系統和借用規則確保了記憶體安全，但也引入了複雜性。複製語義提供了一種替代方案，允許開發者在特定情況下避免所有權轉移的困擾。理解複製的兩種模式：Clone 和 Copy，以及它們的效能和適用場景至關重要。對於需要分享所有權的場景，Rust 提供了 Rc 和 RefCell 等智慧型指標。Rc 允許多個所有者分享同一份資料，而 RefCell 則允許在保持不可變介面的同時修改內部資料。這些機制共同解決了 Rust 中所有權和可變性的挑戰，讓開發者能夠更靈活地管理資源。此外，瞭解位元如何在不同資料型別下被解釋，對於底層系統開發至關重要。相同的位元序列可以表示整數、浮點數或其他資料型別，這取決於程式如何詮釋它們。

圖表翻譯：

以下是程式碼邏輯的視覺化表示：

  flowchart TD
    A[main 函式] --> B[建立 Mailbox 例項]
    B --> C[建立 GroundStation 例項]
    C --> D[呼叫 fetch_sat_ids 函式]
    D --> E[儲存結果到 sat_ids 中]

這個圖表顯示了程式碼的邏輯流程，從建立 Mailbox 例項和 GroundStation 例項，到呼叫 fetch_sat_ids 函式並儲存結果到 sat_ids 中。

4.5.3 值的複製

在 Rust 中，每個物件都有一個唯一的所有者，這意味著在設計軟體時需要進行充分的規劃和/或重構。如前一節所示，要從早期的設計決策中擺脫出來可能需要付出很多努力。

一個替代重構的方法是簡單地複製值。雖然這種做法通常不被鼓勵，但在某些情況下它可能很有用。例如，原始型別如整數是複製的好例子。原始型別對 CPU 來說複製成本很低，以至於 Rust 總是會複製這些型別，而不是擔心所有權被轉移。

型別可以選擇兩種複製模式：克隆（cloning）和複製（copying）。每種模式都由玄貓提供。克隆由 玄貓::clone::Clone 定義，複製模式由 玄貓::marker::Copy 定義。複製模式隱式作用，即當所有權原本會被轉移到內部作用域時，值會被複製而不是移動。另一方面，克隆模式則需要明確呼叫 .clone() 方法來建立新的值。

解決所有權問題

那麼，為什麼 Rust 程式設計師不總是使用 Copy 特徵呢？有三個主要原因：

1. 效能影響：Copy 特徵意味著只會有可忽略的效能影響，這對於數字等小型型別是正確的，但對於任意大小的型別，如 String，則不成立。
2. 參照處理：因為 Copy 建立的是完全的複製，所以它不能正確地處理參照。如果簡單地複製一個對 T 的參照，就會嘗試建立 T 的第二個所有者，這違反了 Rust 的所有權規則。
3. 自定義型別：對於自定義型別，可能需要更複雜的複製邏輯，這時候使用 Clone 特徵可以提供更多的控制權。

克隆和複製之間的差異

總之，Rust 提供了兩種方式來複製值：克隆和複製。雖然 Copy 特徵提供了一種方便的隱式複製機制，但它並不適合所有情況，尤其是當涉及到大型型別或參照時。這時候，使用 Clone 特徵可以提供更多的控制權和靈活性。

實作複製與複製特性

在 Rust 中，Clone 和 Copy 是兩種不同的特性，分別用於實作複製和複製的功能。Clone 特性需要顯式呼叫 clone() 方法，而 Copy 特性則是隱式的，當 ownership 需要轉移時，會自動進行複製。

實作複製特性

要實作 Clone 特性，需要為自定義型別實作 Clone 特性。以下是實作 Clone 特性的範例：

#[derive(Debug)]
struct CubeSat {
    id: u64,
}

impl Clone for CubeSat {
    fn clone(&self) -> Self {
        CubeSat { id: self.id }
    }
}

在這個範例中，CubeSat 型別實作了 Clone 特性，當呼叫 clone() 方法時，會傳回一個新的 CubeSat 例項，該例項的 id 欄位與原始例項相同。

實作複製特性

要實作 Copy 特性，需要為自定義型別實作 Copy 特性。以下是實作 Copy 特性的範例：

#[derive(Debug, Copy, Clone)]
struct CubeSat {
    id: u64,
}

impl Copy for CubeSat {}

在這個範例中，CubeSat 型別實作了 Copy 特性，當 ownership 需要轉移時，會自動進行複製。

使用複製和複製特性

現在我們已經瞭解如何實作 Clone 和 Copy 特性，讓我們看看如何使用它們。以下是使用 Clone 和 Copy 特性的範例：

fn check_status(sat_id: CubeSat) -> StatusMessage {
    StatusMessage::Ok
}

fn main() {
    let sat_a = CubeSat { id: 0 };
    let a_status = check_status(sat_a);
    println!("a: {:?}", a_status);
}

在這個範例中，check_status() 函式需要一個 CubeSat 例項作為引數。由於 CubeSat 型別實作了 Copy 特性，所以當呼叫 check_status() 函式時，會自動進行複製。

如果我們需要顯式呼叫 clone() 方法，可以使用以下方式：

fn main() {
    let sat_a = CubeSat { id: 0 };
    let sat_b = sat_a.clone();
    println!("b: {:?}", sat_b);
}

在這個範例中，呼叫 clone() 方法會傳回一個新的 CubeSat 例項，該例項的 id 欄位與原始例項相同。

實作複製與所有權解決

在 Rust 中，實作 Copy 特徵需要實作 Clone 特徵。這是因為 Copy 是一個更強的特徵，意味著型別可以被安全地複製，而 Clone 則提供了一種方法來建立一個值的副本。

實作複製

要實作 Copy，我們需要先實作 Clone。這是因為 Copy 依賴於 Clone 來建立值的副本。以下是如何實作 Clone 的範例：

#[derive(Debug, Clone, Copy)]
struct CubeSat {
    id: u64,
}

#[derive(Debug, Clone, Copy)]
enum StatusMessage {
    Ok,
}

fn check_status(sat_id: CubeSat) -> StatusMessage {
    //...
}

在這個範例中，我們使用 #[derive(Debug, Clone, Copy)] 來自動實作 Debug、Clone 和 Copy 特徵。這使得我們可以輕鬆地複製 CubeSat 和 StatusMessage 的例項。

解決所有權問題

在 Rust 中，所有權是指值的所有權歸屬誰。當我們將一個值傳遞給函式時，該值的所有權會被轉移給函式。要解決所有權問題，我們可以使用參照或智慧指標。

例如，在 check_status 函式中，我們可以使用參照來避免轉移 CubeSat 的所有權：

fn check_status(sat_id: &CubeSat) -> StatusMessage {
    //...
}

這樣，我們就可以在不轉移所有權的情況下使用 CubeSat 的值。

內容解密：

• 我們使用 #[derive(Debug, Clone, Copy)] 來自動實作 Debug、Clone 和 Copy 特徵。
• 我們使用參照來避免轉移 CubeSat 的所有權。
• 我們可以使用智慧指標來管理所有權。

圖表翻譯：

  flowchart TD
    A[CubeSat] --> B[check_status]
    B --> C[StatusMessage]
    C --> D[傳回狀態]

這個圖表展示了 CubeSat 被傳遞給 check_status 函式，並傳回一個 StatusMessage。

分享擁有權與參照計數

在 Rust 中，分享擁有權是一種允許多個所有者分享同一份資料的機制。這是透過使用 std::rc::Rc 這個 wrapper 型別來實作的。Rc 代表 “reference-counted”，即參照計數。它允許你建立一個可以被多個所有者分享的值，並且當所有所有者都丟棄了對這個值的參照時，這個值才會被從記憶體中移除。

如何使用 Rc

要使用 Rc，你需要先建立一個 Rc 例項，並將你想要分享的值傳遞給它。然後，你可以使用 clone 方法建立對這個值的多個參照。每次你呼叫 clone，參照計數就會增加一次；當你丟棄一個參照時，參照計數就會減少一次。當參照計數達到零時，值就會被從記憶體中移除。

範例

以下是使用 Rc 的一個簡單範例：

use std::rc::Rc;

fn main() {
    // 建立一個 Rc 例項
    let rc = Rc::new(5);

    // 建立對這個值的多個參照
    let rc_clone1 = rc.clone();
    let rc_clone2 = rc.clone();

    // 現在有三個參照了
    println!("Reference count: {}", Rc::strong_count(&rc));
    println!("Reference count: {}", Rc::strong_count(&rc_clone1));
    println!("Reference count: {}", Rc::strong_count(&rc_clone2));

    // 丟棄一個參照
    drop(rc_clone1);

    // 現在只有兩個參照了
    println!("Reference count: {}", Rc::strong_count(&rc));
}

在這個範例中，我們建立了一個 Rc 例項，並將值 5 傳遞給它。然後，我們使用 clone 方法建立對這個值的多個參照。最後，我們丟棄了一個參照，並觀察到參照計數的變化。

智慧型指標系統：生命週期、所有權和借用

在 Rust 中，管理記憶體和資源的生命週期是非常重要的。為了達到這個目的，Rust 提供了幾種機制，包括生命週期（Lifetimes）、所有權（Ownership）和借用（Borrowing）。在本章中，我們將深入探討這些概念，並學習如何使用它們來寫出更安全、更高效的程式碼。

智慧型指標：Rc 和 RefCell

Rust 的標準函式庫中提供了兩種智慧型指標：Rc 和 RefCell。Rc 是一個參照計數指標，它允許你分享同一個值的所有權。每次你呼叫 clone() 方法時，參照計數就會增加；每次 Drop 被呼叫時，參照計數就會減少。當參照計數達到零時，值就會被釋放。

use std::rc::Rc;

#[derive(Debug)]
struct GroundStation {}

fn main() {
    let base = Rc::new(GroundStation {});
    println!("{:?}", base);
}

然而，Rc 並不允許你修改值。為了實作這個功能，你需要使用 RefCell 來包裝你的值。RefCell 是一個提供內部可變性的型別，它允許你在保持不變的外表下修改內部的值。

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct GroundStation {
    radio_freq: f64, // MHz
}

fn main() {
    let base = Rc::new(RefCell::new(GroundStation { radio_freq: 87.65 }));
    // 修改 radio_freq
    base.borrow_mut().radio_freq = 75.31;
    println!("{:?}", base);
}

在這個例子中，我們使用 Rc 和 RefCell 來建立一個可以分享和修改的 GroundStation 例項。Rc 提供了分享所有權的功能，而 RefCell 則允許我們修改內部的值。

內容解密：

在上面的程式碼中，我們使用 Rc 和 RefCell 來建立一個可以分享和修改的 GroundStation 例項。Rc 提供了分享所有權的功能，而 RefCell 則允許我們修改內部的值。這個例子展示瞭如何使用這兩個型別來實作內部可變性和分享所有權。

圖表翻譯：

  flowchart TD
    A[GroundStation] --> B[Rc]
    B --> C[RefCell]
    C --> D[修改 radio_freq]
    D --> E[println]

這個圖表展示瞭如何使用 Rc 和 RefCell 來建立一個可以分享和修改的 GroundStation 例項，並且如何修改內部的值。

使用Rc和RefCell實作可變性

在Rust中，Rc和RefCell是兩個重要的型別，它們可以幫助我們實作可變性。下面是一個使用Rc和RefCell來包裝自定義型別的例子。

use std::rc::Rc;
use std::cell::RefCell;

// 定義一個GroundStation結構體
struct GroundStation {
    radio_freq: f64,
}

fn main() {
    // 建立一個Rc<RefCell<GroundStation>>例項
    let base: Rc<RefCell<GroundStation>> = Rc::new(RefCell::new(GroundStation {
        radio_freq: 87.65,
    }));

    //...
}

在這個例子中，我們定義了一個GroundStation結構體，它有一個radio_freq欄位。然後，我們使用Rc::new和RefCell::new來包裝這個結構體，建立了一個Rc<RefCell<GroundStation>>例項。

使用Rc和RefCell的好處

使用Rc和RefCell可以幫助我們實作可變性。Rc可以讓多個指標分享同一個值，而RefCell可以讓我們在執行期動態地決定是否允許可變性。

let mut base = base.borrow_mut();
base.radio_freq = 90.0;

在這個例子中，我們使用borrow_mut方法來取得一個可變的參照，然後修改radio_freq欄位的值。

內容解密：

• Rc和RefCell是兩個重要的型別，它們可以幫助我們實作可變性。
• Rc可以讓多個指標分享同一個值，而RefCell可以讓我們在執行期動態地決定是否允許可變性。
• 我們可以使用borrow_mut方法來取得一個可變的參照，然後修改值。

圖表翻譯：

  flowchart TD
    A[建立Rc<RefCell<GroundStation>>例項] --> B[取得可變參照]
    B --> C[修改radio_freq欄位]
    C --> D[傳回修改後的值]

在這個圖表中，我們展示瞭如何使用Rc和RefCell來包裝自定義型別，實作可變性。首先，我們建立了一個Rc<RefCell<GroundStation>>例項，然後取得一個可變參照，修改radio_freq欄位，最後傳回修改後的值。

Rust 中的可變借用與所有權

在 Rust 中，管理記憶體安全是一個重要的概念。Rust 使用所有權和借用機制來確保記憶體安全。以下是關於可變借用的一個例子：

fn main() {
    let mut base = Base { radio_freq: 100.0 };

    println!("base: {:?}", base);

    {
        let mut base_2 = base.borrow_mut();
        base_2.radio_freq -= 12.34;
        println!("base_2: {:?}", base_2);
    }

    println!("base: {:?}", base);

    // 如果我們在這裡嘗試再次可變借用 base，編譯器會報錯
    // 因為 base 還被 base_2 參照著
    // let mut base_3 = base.borrow_mut();
}

在這個例子中，我們定義了一個 Base 結構體，它包含一個 radio_freq 欄位。我們建立了一個可變的 base 例項，並列印它的初始值。

接下來，我們使用 borrow_mut 方法對 base 進行可變借用，並將結果儲存到 base_2 中。這樣做的話，base_2 就可以修改 base 的內容了。然後，我們列印 base_2 的值。

但是，如果我們試圖再次對 base 進行可變借用，就會出現編譯錯誤。因為 base 還被 base_2 參照著，所以不能再次借用。

這是因為 Rust 的借用規則：在任意給定時間，對於某個值，或者存在一個可變參照，或者存在多個不可變參照，但不能同時存在。

內容解密：

上述程式碼展示了 Rust 中的可變借用機制。當我們使用 borrow_mut 方法對某個值進行可變借用時，Rust 會確保該值在借用期間不會被其他地方修改或存取，這樣就可以確保記憶體安全。

let mut base_2 = base.borrow_mut();

這行程式碼對 base 進行可變借用，並將結果儲存到 base_2 中。這樣做的話，base_2 就可以修改 base 的內容了。

base_2.radio_freq -= 12.34;

這行程式碼修改了 base_2 的 radio_freq 欄位的值。

println!("base_2: {:?}", base_2);

這行程式碼列印了 base_2 的值。

圖表翻譯：

以下是上述程式碼的流程圖：

  flowchart TD
    A[開始] --> B[建立 base 例項]
    B --> C[對 base 進行可變借用]
    C --> D[修改 base_2 的內容]
    D --> E[列印 base_2 的值]
    E --> F[嘗試再次對 base 進行可變借用]
    F --> G[編譯器報錯]

這個流程圖展示了上述程式碼的執行流程。首先，我們建立了一個 base 例項，然後對它進行可變借用，修改了 base_2 的內容，列印了 base_2 的值。最後，我們嘗試再次對 base 進行可變借用，但是編譯器報錯了。

Rust 中的所有權和借用

Rust 的所有權和借用系統是其最強大的功能之一，能夠確保記憶體的安全使用。以下是關於所有權和借用的重點總結：

所有權

• 每個值都有一個所有者，這個所有者負責在值的生命週期結束時清理這個值。
• 值的生命週期是指存取這個值是合法的時間段。當生命週期結束後，存取這個值將會導致編譯錯誤。

借用

• 借用是一種存取值的方式，而不需要取得其所有權。
• 有兩種型別的借用：不可變借用（read-only）和可變借用（read-write）。
• 在任何時候，只能有一個可變借用存在。

解決借用檢查器問題

• 如果編譯器因為借用檢查器而拒絕編譯你的程式，可能需要重新思考程式的設計。
• 使用較短生命週期的值，而不是長時間存在的值。
• 借用可以是不可變的或可變的。
• 複製一個值可以是一種解決借用檢查器問題的實用方法。為此，可以實作 Clone 或 Copy 特性。

參考計數

• Rust 支援參考計數語義，可以透過 Rc<T> 來實作。
• Rc<T> 不是執行緒安全的。在多執行緒程式碼中，應該使用 Arc<T> 來替代 Rc<T>，並使用 Arc<Mutex<T>> 來替代 Rc<RefCell<T>>。

內部可變性

• Rust 支援內部可變性，這使得型別可以呈現為不可變的，即使其值可以隨時間改變。

系統程式設計深度解析

系統程式設計是 Rust 的一個重要應用領域。以下是系統程式設計的一些重點：

Rust 的系統程式設計能力

• Rust 提供了強大的系統程式設計能力，包括命令列工具、函式庫、圖形應用、網路應用和作業系統核心等。
• 每個章節都會包含至少一個大型專案，涵蓋新的語言特性。

資料深入探討

• 資料是系統程式設計中的重要組成部分。Rust 提供了強大的資料處理能力，包括資料結構、檔案系統和網路通訊等。

內容解密：

// 定義一個結構體
struct Base {
    radio_freq: f64,
}

fn main() {
    // 建立一個 Base 例項
    let mut base = Base { radio_freq: 10.0 };

    // 修改 base 的 radio_freq 欄位
    base.radio_freq += 43.21;

    // 列印 base 的值
    println!("base: {:?}", base);

    // 建立另一個 Base 例項
    let base_3 = Base { radio_freq: 20.0 };

    // 列印 base_3 的值
    println!("base_3: {:?}", base_3);
}

圖表翻譯：

  flowchart TD
    A[開始] --> B[定義結構體]
    B --> C[建立 Base 例項]
    C --> D[修改 radio_freq 欄位]
    D --> E[列印 base 值]
    E --> F[建立另一個 Base 例項]
    F --> G[列印 base_3 值]
    G --> H[結束]

這個程式碼定義了一個 Base 結構體，並建立了兩個 Base 例項，分別修改和列印了它們的 radio_freq 欄位。Mermaid 圖表展示了程式碼的執行流程。

資料的深度探索

在本章中，我們將探索如何將二進位制資料（0和1）轉換成更複雜的物件，如文字、圖片和聲音。同時，我們也會觸及電腦如何進行計算的話題。

透過玄貓的指導，您將會模擬一個完整的電腦系統，包括中央處理器（CPU）、記憶體和使用者定義的函式。您將會將浮點數拆解成一個自定義的資料型別，只需使用單一byte。這章節將介紹一些可能不熟悉的術語，如位元組順序（endianness）和整數溢位（integer overflow）。

5.1 位元模式和型別

一個小但重要的課題是，單一位元模式可以有不同的含義。高階語言（如Rust）的型別系統只是對現實的一種人工抽象。瞭解這點在您開始拆解這種抽象並深入瞭解電腦工作原理時至關重要。

本章涵蓋以下內容：

• 學習電腦如何表示資料
• 建立一個可工作的CPU模擬器
• 建立您自己的數值資料型別
• 瞭解浮點數

位元模式示例

清單 5.1（位於ch5-int-vs-int.rs）展示瞭如何使用相同的位元模式來代表兩個不同的數字。型別系統（而非CPU）決定了這種區別。以下是清單的輸出：

a: 1100001111000011 50115
b: 1100001111000011 -15421

fn main() {
    let a: u16 = 50115;
    let b: i16 = -15421;
    println!("a: {:016b} {}", a, a);
    println!("b: {:016b} {}", b, b);
}

不同對映之間的位元字串和數字解釋了二進位制檔案和文字檔案之間的部分割槽別。文字檔案只是一種恰好遵循位元字串和字元之間一致對映的二進位制檔案。這種對映被稱為編碼。任意檔案不會向外界描述其含義，使其變得不透明。

將位元模式轉換為其他型別

如果我們要求Rust將玄貓產生的位元模式視為某種型別呢？以下清單提供了一個答案。

fn main() {
    let a: f32 = 42.42;
    let frankentype: u32 = unsafe {
        std::mem::transmute(a)
    };
}

這個例子展示瞭如何使用transmute函式將浮點數a轉換為無符號32位整數frankentype。請注意，這種轉換是無安全性的，需要使用unsafe關鍵字。

圖表翻譯：

  graph LR
    A[二進位制資料] -->|轉換|> B[文字]
    A -->|轉換|> C[圖片]
    A -->|轉換|> D[聲音]
    B -->|編碼|> E[文字檔案]
    C -->|編碼|> F[圖片檔案]
    D -->|編碼|> G[聲音檔案]

這個圖表展示了二進位制資料如何被轉換成不同的格式，如文字、圖片和聲音，並且如何被編碼成不同的檔案型別。

解析位元組的多重詮釋

在電腦科學中，資料的表示方式取決於其資料型別。同一序列的位元可以根據不同的資料型別被解釋為不同的值。以下是展示這一概念的 Rust 程式碼：

fn main() {
    let a: f32 = 42.42;
    let frankentype: u32 = unsafe { std::mem::transmute(a) };

    println!("{}", frankentype);
    println!("{:032b}", frankentype);

    let b: f32 = unsafe { std::mem::transmute(frankentype) };

    println!("{}", b);
    assert_eq!(a, b);
}

當這段程式碼被編譯和執行時，它會輸出以下內容：

1110027796
01000010001010011010111000010100
42.42

這個結果展示了同一序列的位元可以根據不同的資料型別（在這裡是 u32 和 f32）被解釋為不同的值。frankentype 這個變數最初被賦予了一個 f32 值的位元表示，然後它被轉換為 u32 並輸出。接著，這個 u32 值又被轉換回 f32 並輸出，以展示它仍然代表著原來的浮點數值。

位元表示的多重詮釋

• 整數表示：當一串位元被視為整數時，它根據位元的位置和值計算出一個十進位制的整數值。
• 浮點數表示：同一串位元可以根據浮點數的編碼規則（如 IEEE 754）被解釋為一個浮點數值，包括了符號位、指數和尾數。

結論：掌握 Rust 的所有權和借用系統

從底層位元模式到高階資料結構，本文深入探討了 Rust 的核心概念：所有權和借用。透過剖析 Copy、Clone、Rc 和 RefCell 等機制，我們理解了 Rust 如何在編譯時期保障記憶體安全，並提供有效管理資源生命週期的方法。這套機制雖然在初期可能提高了學習曲線，但從長遠來看，它有效避免了常見的記憶體錯誤，例如 dangling pointers 和 data races，對於建構可靠且高效能的系統至關重要。對於追求高效能的系統程式設計而言，理解 Rust 的所有權和借用系統，如同掌握精巧的工匠工具，能雕琢出更安全、更穩固的軟體根本。展望未來，隨著 Rust 生態系統的蓬勃發展，預期會有更多創新工具和最佳實務出現，進一步簡化資源管理的複雜度，並提升開發效率。對於有志於系統程式設計的開發者而言，Rust 無疑是一門值得投入學習和探索的現代化語言。