Rust 所有權與移動語義詳解

– 14 分鐘閱讀

Rust 的所有權系統確保記憶體安全，無需垃圾回收機制。所有權的轉移伴隨著值的移動，當值超出作用域時，其解構函式會被自動呼叫以釋放資源。理解所有權和移動語義對於編寫高效且安全的 Rust 程式碼至關重要。複製語義適用於實作 Copy trait 的型別，允許值在指定時進行複製而非移動。所有權的移動也發生在函式呼叫中，當值作為引數傳遞或作為傳回值傳回時，所有權會在不同作用域之間轉移。

重新繫結

在 Rust 中，重新繫結（rebinding）是指將一個變數重新指定給另一個值。在 listing 4.3 中，a_status 變數被重新繫結給了 check_status(sat_a) 的傳回值。

瞭解Rust的所有權和移動語義

在Rust中，所有權（ownership）和移動語義（move semantics）是兩個非常重要的概念。所有權決定了誰是某個值的主人，而移動語義則決定了當值被賦予給另一個變數時會發生什麼事。

所有權的移動

當你將一個值賦予給另一個變數時，所有權就會被移動。這意味著原來的變數不再擁有該值，新的變數成為了新的主人。例如：

fn main() {
    let sat_a = String::from("Hello");
    let sat_b = sat_a;
    println!("{}", sat_a); // 錯誤：sat_a 已經不是 String 的主人了
}

在上面的例子中，sat_a 的所有權被移動到了 sat_b，所以 sat_a 不再能夠存取該值。

Copy語義

但是，有些型別的值可以被複製，而不是移動。這些型別實作了 Copy 特徵。例如，整數和浮點數都是 Copy 的：

fn main() {
    let a = 123;
    let b = a;
    println!("{}", a); // 沒問題：a 仍然是 123 的主人
}

在上面的例子中，a 的值被複製到了 b，所以 a 仍然能夠存取該值。

Move語義和Copy語義的區別

Rust 的大多數型別都具有移動語義，而不是複製語義。這意味著當你將一個值賦予給另一個變數時，所有權就會被移動。只有實作了 Copy 特徵的型別才具有複製語義。

實作Copy特徵

如果你想要讓你的型別具有複製語義，你需要實作 Copy 特徵。例如：

#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1;
    println!("p1.x = {}", p1.x); // 沒問題：p1 仍然是 Point 的主人
}

在上面的例子中，Point 結構體實作了 Copy 特徵，所以當你將 p1 賦予給 p2 時，p1 的值被複製到了 p2。

Rust 所有權的運作機制

在 Rust 中，所有權（Ownership）是一個非常重要的概念，它決定了程式碼中資料的生命週期和存取許可權。當一個值被建立時，它會被賦予一個所有者（Owner），而這個所有者負責管理這個值的生命週期。

所有權的移動

當我們將一個值傳遞給另一個函式時，所有權就會從原來的所有者轉移到新的所有者。這個過程被稱為所有權的移動（Move）。例如，在下面的程式碼中，sat_a 的所有權被轉移到 check_status() 函式中：

let sat_a = CubeSat { }
check_status(sat_a)

在 check_status() 函式中，sat_a 的所有權被接收並使用。當 check_status() 函式傳回時，sat_a 的所有權就會被釋放。

所有權的範圍

所有權的範圍（Scope）是指所有者對值的存取許可權的有效範圍。當所有者的範圍結束時，值的所有權就會被自動釋放。例如，在下面的程式碼中，sat_a 的所有權在 drop(sat_a) 時被釋放：

let sat_a = CubeSat { }
check_status(sat_a)
drop(sat_a)

使用值

當我們使用一個值時，該值的所有權就會被轉移到使用者中。例如，在下面的程式碼中，use_value() 函式接收 val 的所有權：

fn use_value<T>(val: T) {
    // 使用 val
}

在這個例子中，use_value() 函式是泛型的，這意味著它可以接收任何型別的值。

圖表翻譯：

  flowchart TD
    A[建立值] --> B[賦予所有權]
    B --> C[移動所有權]
    C --> D[釋放所有權]
    D --> E[結束範圍]

這個圖表展示了 Rust 中的所有權運作機制，從建立值到賦予所有權、移動所有權、釋放所有權，最終結束範圍。

內容解密：

在 Rust 中，所有權是管理資料生命週期和存取許可權的一個重要機制。當我們建立一個值時，它會被賦予一個所有者，而這個所有者負責管理這個值的生命週期。當我們將一個值傳遞給另一個函式時，所有權就會從原來的所有者轉移到新的所有者。這個過程被稱為所有權的移動。當所有者的範圍結束時，值的所有權就會被自動釋放。在使用值時，該值的所有權就會被轉移到使用者中。瞭解 Rust 中的所有權運作機制對於寫出正確和安全的程式碼至關重要。

生命週期、所有權和借用

在 Rust 中，瞭解生命週期、所有權和借用是非常重要的。這些概念幫助我們管理記憶體和避免常見的錯誤，如空指標和野指標。

什麼是生命週期？

生命週期是指一個值從建立到被丟棄的時間範圍。在 Rust 中，每個值都有一個生命週期，當值超出其生命週期時，就會被自動丟棄。

什麼是所有權？

所有權是指對一個值的控制權。在 Rust 中，每個值都有一個所有者，當所有者超出其生命週期時，值就會被丟棄。

什麼是借用？

借用是指臨時使用一個值而不取得其所有權。在 Rust 中，有兩種借用方式：不可變借用（&T）和可變借用（&mut T）。

不可變借用

不可變借用允許你使用一個值而不修改它。當你借用一個值時，你可以讀取其內容，但不能修改它。

fn use_value(val: &i32) {
    println!("{}", val);
}

fn main() {
    let x = 10;
    use_value(&x);
    println!("{}", x); //仍然可以存取x
}

可變借用

可變借用允許你修改一個值。當你借用一個值時，你可以讀取和修改其內容。

fn use_value(val: &mut i32) {
    *val = 20;
}

fn main() {
    let mut x = 10;
    use_value(&mut x);
    println!("{}", x); //印出20
}

移動語義

當你將一個值傳遞給一個函式時，該值的所有權就會被轉移給函式。如果函式傳回後，該值就會被丟棄。

struct Demo {
    a: i32,
}

fn use_value(_val: Demo) {}

fn main() {
    let demo = Demo { a: 123 };
    use_value(demo);
    // println!("{}", demo.a); //錯誤，demo已經被移動
}

但是，如果函式傳回後，該值仍然可以被存取，那就意味著該值沒有被移動。

fn use_value(_val: &Demo) {}

fn main() {
    let demo = Demo { a: 123 };
    use_value(&demo);
    println!("{}", demo.a); //正確，demo仍然可以被存取
}

程式設計基礎：函式呼叫與狀態檢查

在程式設計中，函式（Function）是一個基本的結構單元，負責執行特定的任務。當我們呼叫一個函式時，程式會執行該函式內的程式碼，並可能傳回一些結果。瞭解函式的呼叫和傳回機制是掌握程式設計的關鍵。

函式呼叫與引數傳遞

當我們呼叫一個函式時，通常需要傳遞一些引數給函式，以便它能夠正確地執行任務。這些引數被稱為引數（Arguments）。例如，在下面的例子中，main() 和 check_status() 就是兩個函式，它們可能需要傳遞不同的引數來執行不同的任務。

def main():
    # 主程式進入點
    pass

def check_status(status_code):
    # 檢查狀態程式碼
    if status_code == 200:
        return "Ok"
    else:
        return "Error"

狀態檢查與回傳值

在程式設計中，狀態檢查是一個非常重要的概念。它允許我們根據不同的條件執行不同的動作。例如，當我們呼叫 check_status() 函式時，它會根據傳遞的狀態程式碼傳回相應的狀態訊息。

def check_status(status_code):
    # 狀態檢查
    if status_code == 200:
        return "Ok"
    else:
        return "Error"

status_code = 200
print(check_status(status_code))  # 輸出: Ok

符號與基礎資料型別

在程式設計中，符號（Symbols）是用來代表特定值或概念的名字。例如，sat_a、sat_b 和 sat_c 可能是代表衛星的狀態的符號。基礎資料型別（如整數、浮點數、字串等）則是用來儲存和操作資料的基本單元。

sat_a = "Active"
sat_b = "Inactive"
sat_c = "Maintenance"

print(sat_a)  # 輸出: Active
print(sat_b)  # 輸出: Inactive
print(sat_c)  # 輸出: Maintenance

主控臺輸出與動作

最後，程式設計中經常需要與使用者進行互動，包括輸出資訊到主控臺（Console）和執行特定的動作（Actions）。這些動作可能包括讀取使用者輸入、寫入檔案等。

def print_to_console(message):
    # 輸出資訊到主控臺
    print(message)

print_to_console("Hello, World!")  # 輸出: Hello, World!

內容解密：

以上程式碼示範了基本的程式設計概念，包括函式呼叫、狀態檢查、符號和基礎資料型別的使用，以及主控臺輸出和動作的執行。每個部分都對應著特定的程式設計原則和實踐，幫助開發者建立堅實的程式設計基礎。

圖表翻譯：

  flowchart TD
    A[主程式] --> B[函式呼叫]
    B --> C[狀態檢查]
    C --> D[符號與資料型別]
    D --> E[主控臺輸出]
    E --> F[動作執行]

此圖表展示了程式設計中的基本流程，從主程式開始，到函式呼叫、狀態檢查、符號和資料型別的使用，最終到主控臺輸出和動作的執行。每個步驟都對應著特定的程式設計概念，幫助開發者理解程式設計的邏輯流程。

4.3 所有權的概念：什麼是所有權？它有什麼責任？

在 Rust 的世界中，所有權的概念相當有限。所有者在其值的生命週期結束時會進行清理。當值超出範圍或其生命週期因其他原因結束時，其解構函式會被呼叫。解構函式是一個移除值在程式中痕跡的函式，由玄貓負責。你通常不會在大多數 Rust 程式碼中找到對解構函式的呼叫。編譯器會在追蹤每個值的生命週期的過程中注入這些程式碼。

為了一個型別提供自訂解構函式，我們需要實作 Drop 特徵。這通常是在使用不安全區塊分配記憶體的情況下需要的。Drop 有一個方法 drop(&mut self)，可用於進行任何必要的清理活動。

這個系統的一個含義是，值不能超出其所有者的生命週期。這種情況可能會使根據參考的資料結構（如樹和圖）感覺稍微官僚一些。如果樹的根節點是整個樹的所有者，它不能在不考慮所有權的情況下被移除。

最後，與洛克的個人財產概念不同，所有權不意味著控制或主權。事實上，值的「所有者」不具有特殊的存取其所擁有資料的許可權。它們也不具有限制他人存取其值的能力。所有者不具有對其他程式碼段借用其值的發言權。

4.4 所有權如何移動

在 Rust 程式中，有兩種方式可以將所有權從一個變數轉移到另一個變數。第一種是透過 移動（move）。第二種是透過 克隆（clone），無論是作為引數還是傳回值。在重新審視我們原始程式碼（清單 4.3）時，我們可以看到 sat_a 一開始就擁有了一個 CubeSat 物件：

fn main() {
    let sat_a = CubeSat { id: 0 };
    //...
}

在這個例子中，sat_a 是 CubeSat 物件的所有者。當 sat_a 超出範圍時，CubeSat 物件也會被清理。

內容解密：

struct CubeSat {
    id: i32,
}

impl Drop for CubeSat {
    fn drop(&mut self) {
        println!("CubeSat {} 被清理", self.id);
    }
}

fn main() {
    let sat_a = CubeSat { id: 0 };
    //...
}

在這個例子中，我們定義了一個 CubeSat 型別，並實作了 Drop 特徵來提供自訂解構函式。當 sat_a 超出範圍時，CubeSat 物件的解構函式會被呼叫，並列印一條訊息。

圖表翻譯：

  graph LR
    A[main] -->|建立|> B[CubeSat]
    B -->|移動|> C[sat_a]
    C -->|超出範圍|> D[清理]
    D -->|呼叫解構函式|> E[列印訊息]

這個圖表展示了 CubeSat 物件的生命週期，以及如何將所有權從 main 函式轉移到 sat_a 變數。當 sat_a 超出範圍時，CubeSat 物件的解構函式會被呼叫，並列印一條訊息。

Rust 中的所有權和變數繫結

在 Rust 中，所有權（ownership）是一個非常重要的概念。它決定了誰擁有某個值的所有權，並且當這個值被指定給另一個變數時，所有權就會被轉移。

變數繫結

當我們將一個值指定給一個變數時，實際上是將這個值的所有權繫結到這個變數上。這個過程被稱為變數繫結（variable binding）。

fn main() {
    let sat_a = CubeSat { id: 0 };
    //...
}

在上面的例子中，sat_a 是一個變數，它綁定了 CubeSat { id: 0 } 的所有權。

所有權轉移

當我們將一個值指定給另一個變數時，所有權就會被轉移。例如：

fn main() {
    let sat_a = CubeSat { id: 0 };
    let new_sat_a = sat_a;
    //...
}

在上面的例子中，sat_a 的所有權被轉移給了 new_sat_a。

函式呼叫中的所有權轉移

當我們將一個值作為引數傳遞給一個函式時，所有權也會被轉移。例如：

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

fn main() {
    let sat_a = CubeSat { id: 0 };
    let a_status = check_status(sat_a);
    //...
}

在上面的例子中，sat_a 的所有權被轉移給了 check_status 函式。

傳回所有權

如果函式傳回一個值，則這個值的所有權會被轉移給呼叫者。例如：

fn check_status(sat_id: CubeSat) -> CubeSat {
    println!("{:?}: {:?}", sat_id, StatusMessage::Ok);
    sat_id
}

fn main() {
    let sat_a = CubeSat { id: 0 };
    let sat_a = check_status(sat_a);
    //...
}

在上面的例子中，check_status 函式傳回了 sat_id 的所有權，然後這個所有權被轉移給了 main 函式中的 sat_a 變數。

Rust 中的所有權與借用：深入理解 check_status 函式

在 Rust 中，所有權與借用是兩個非常重要的概念，它們決定了如何管理記憶體以及如何在不同作用域之間傳遞資料。在這個例子中，我們將深入探討 check_status 函式，瞭解它如何傳回所有權並探索相關的概念。

check_status 函式

fn check_status(sat_id: CubeSat) -> CubeSat {
    println!("{:?}: {:?}", sat_id, StatusMessage::Ok);
    sat_id
}

這個函式接受一個 CubeSat 例項作為引數，並傳回同一型別的值。讓我們一步一步地分析這個函式的行為：

  1. 接受所有權：當 check_status 函式被呼叫時，它接受了 CubeSat 例項的所有權。這意味著，當 CubeSat 例項被傳遞給函式時，其所有權就被轉移到函式內部。
  2. 列印訊息：函式內部使用 println! 宏列印了一條訊息，包含了 CubeSat 例項的 id 和一個狀態訊息。
  3. 傳回所有權：函式最後傳回了 CubeSat 例項的所有權，這意味著所有權被轉移回呼叫者。

在 main 函式中使用 check_status

現在，讓我們看看 main 函式中如何使用 check_status 函式：

fn main() {
    let sat_a = CubeSat { id: 0 };
    let sat_b = CubeSat { id: 1 };
    let sat_c = CubeSat { id: 2 };

    let sat_a = check_status(sat_a);
    let sat_b = check_status(sat_b);
    let sat_c = check_status(sat_c);
}

在 main 函式中，我們建立了三個 CubeSat 例項：sat_a、sat_b 和 sat_c。然後，我們將每個例項傳遞給 check_status 函式，並將傳回的值重新指定給原來的變數。

結果

經過上述操作後，每個 CubeSat 例項的所有權都被轉移到 check_status 函式內部，然後又被傳回並重新指定給原來的變數。這意味著，原來的 CubeSat 例項仍然可以被使用，但其內容已經被修改過。

重新理解程式碼的所有權轉移

在這個範例中，我們看到 check_status() 函式傳回原始的 sat_a 值，並將其指定給新的 let繫結。這意味著原始的 sat_a、sat_b 和 sat_c 變數仍然保持不變，而新的繫結則取代了舊有的值。

let sat_a = check_status(sat_a);
let sat_b = check_status(sat_b);
let sat_c = check_status(sat_c);

這段程式碼展示了 Rust 中的所有權轉移機制。當 check_status() 函式傳回原始的 sat_a 值時，新的 let繫結就會接管這個值的所有權。這意味著原始的 sat_a 變數不再擁有這個值的所有權，而新的繫結則成為新的所有者。

程式碼分析

讓我們一步一步地分析這段程式碼：

  1. let sat_a = check_status(sat_a);：這行程式碼呼叫 check_status() 函式，並將其傳回值指定給新的 sat_a 變數。
  2. let sat_b = check_status(sat_b);：同樣地，這行程式碼呼叫 check_status() 函式，並將其傳回值指定給新的 sat_b 變數。
  3. let sat_c = check_status(sat_c);：最後，這行程式碼呼叫 check_status() 函式，並將其傳回值指定給新的 sat_c 變數。

結果

執行這段程式碼後，輸出結果如下：

CubeSat { id: 0 }: Ok
CubeSat { id: 1 }: Ok
CubeSat { id: 2 }: Ok
CubeSat { id: 0 }: Ok
CubeSat { id: 1 }: Ok
CubeSat { id: 2 }: Ok

這個結果表明，原始的 sat_a、sat_b 和 sat_c 變數仍然保持不變，而新的繫結則取代了舊有的值。

圖表翻譯：

  flowchart TD
    A[原始 sat_a] --> B[check_status()]
    B --> C[新的 sat_a]
    A --> D[原始 sat_b]
    D --> E[check_status()]
    E --> F[新的 sat_b]
    A --> G[原始 sat_c]
    G --> H[check_status()]
    H --> I[新的 sat_c]

這個流程圖展示了原始的 sat_a、sat_b 和 sat_c 變數如何被轉移給新的繫結。

程式設計中的物件擁有權轉移

在程式設計中，物件的擁有權轉移是一個重要的概念，尤其是在多個物件之間分享資源或狀態時。下面是一個簡單的範例，展示瞭如何在 Python 中實作物件擁有權轉移。

程式碼實作

class CubeSat:
    def __init__(self, name):
        self.name = name

def check_status(sat_id):
    # 在這裡，sat_id 是一個區域性變數，暫時持有 CubeSat 物件的參照
    print(f"檢查 {sat_id.name} 的狀態")

# 建立三個 CubeSat 物件
sat_a = CubeSat("A")
sat_b = CubeSat("B")
sat_c = CubeSat("C")

# 初始狀態
print("初始狀態：")
check_status(sat_a)
check_status(sat_b)
check_status(sat_c)

# 轉移擁有權
print("\n轉移擁有權：")
sat_id = sat_a
check_status(sat_id)
sat_id = sat_b
check_status(sat_id)
sat_id = sat_c
check_status(sat_id)

內容解密：

在上述程式碼中，我們定義了一個 CubeSat 類別，代表一個 CubeSat 物件。每個物件都有一個 name 屬性。check_status 函式接受一個 CubeSat 物件作為引數，並印出該物件的狀態。

在 main 函式中，我們建立了三個 CubeSat 物件：sat_a、sat_b 和 sat_c。然後，我們呼叫 check_status 函式三次，分別傳入每個 CubeSat 物件。

接下來，我們展示了物件擁有權轉移的過程。sat_id 是一個區域性變數，暫時持有 CubeSat 物件的參照。在每次呼叫 check_status 函式時，sat_id 都會指向不同的 CubeSat 物件，因此實作了物件擁有權轉移。

程式流程

  1. 初始化：建立三個 CubeSat 物件。
  2. 檢查狀態：呼叫 check_status 函式，傳入每個 CubeSat 物件。
  3. 轉移擁有權：使用 sat_id 區域性變數暫時持有 CubeSat 物件的參照，並呼叫 check_status 函式。

圖表翻譯：

  flowchart TD
    A[初始化] --> B[檢查狀態]
    B --> C[轉移擁有權]
    C --> D[檢查狀態]
    D --> E[結束]

圖表翻譯：

上述流程圖展示了程式的執行流程。從初始化開始，然後檢查每個 CubeSat 物件的狀態，接著轉移擁有權，並再次檢查狀態，最後結束程式。這個流程圖清晰地表明瞭物件擁有權轉移的過程。

解決所有權問題

Rust 的所有權系統是一個優秀的設計，它提供了一種在不需要垃圾收集器的情況下實作記憶體安全的途徑。然而，這個系統也可能會在你不完全理解它的工作原理時造成困擾，特別是當你試圖將過去的程式設計經驗應用於新的程式設計正規化時。

有四種一般性的策略可以幫助解決所有權問題：

  1. 使用參照：當不需要完整所有權時，使用參照可以避免所有權的轉移。
  2. 複製值：如果需要使用同一份資料的多個副本，複製值可以是一個選擇。
  3. 重構程式碼：減少長期存活物件的數量，可以幫助減少所有權問題。
  4. 包裝資料：使用設計來幫助解決移動問題的型別，可以簡化所有權的管理。

從底層實作到高階應用的全面檢視顯示，Rust 的所有權系統和變數繫結機制，雖然在初學階段可能造成一些困擾，但卻是確保記憶體安全和效率的關鍵。透過移動語義、複製語義和借用機制，Rust 精確地控制了資料的生命週期和存取許可權，避免了常見的記憶體錯誤，例如懸空指標和資料競爭。然而，理解所有權的移動、複製和借用等概念至關重要，才能有效地運用 Rust 的所有權系統。技術堆疊的各層級協同運作中體現，Rust 的所有權系統與其他語言的垃圾回收機制相比，提供了更精細的記憶體管理控制，並在編譯時就能夠檢測出潛在的記憶體錯誤，從而提高了程式的可靠性和效能。對於重視效能和安全的系統級程式設計，Rust 的所有權系統無疑是一項值得深入學習和掌握的技術。玄貓認為，Rust 的所有權系統雖然具有學習曲線，但其帶來的記憶體安全和效能優勢，使其成為構建高可靠性和高效能應用程式的理想選擇，值得開發者投入時間和精力深入研究。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。