Rust 的所有權模型是其最為強大與具代表性的特性之一。它無需垃圾回收機制（Garbage Collection, GC）就能提供記憶體安全，進而讓 Rust 成為一個高效與可靠的程式語言。如果你是從 C++、Java 或 Python 等程式語言轉過來的開發者，理解 Rust 的所有權系統一開始可能會覺得有些困難。在這篇文章中，我們將逐步解析這個重要的概念。
什麼是 Rust 的所有權？
所有權是 Rust 管理記憶體的獨特方式。Rust 並非採用垃圾回收或手動記憶體管理，而是在編譯時期強制執行嚴格的所有權規則。這些規則確保了記憶體安全，並防止平行程式中的資料競爭（Data Race）。
以下是三個關鍵的所有權規則：
- Rust 中的每個值都有一個單一擁有者（Owner）。
- 當擁有者超出作用域（Scope）時，Rust 會自動釋放該值。
- 所有權可以被轉移（移動）或借用（不可變或可變）。
移動、複製和克隆
Rust 中理解所有權的關鍵在於理解移動（Move）、複製（Copy）和克隆（Clone）的區別。這些概念直接影響了變數如何被指定和使用。
移動語意（Move Semantics）
在將一個變數的值賦給另一個變數時，所有權會被轉移。考慮以下範例：
fn main() {
let s1 = String::from("hello");
let s2 = s1; // 所有權移動到 s2，s1 不再有效
// println!("{}", s1); // 這會導致編譯時期錯誤
}
由於 String 是在堆積積（Heap）上分配的，Rust 透過使 s1 在所有權移動到 s2 時失效，來防止雙重釋放（Double-Free）錯誤。
複製語意（Copy Semantics）
某些型別實作了 Copy 特徵（Trait），這表示它們在指定時會被複製而不是移動。這些型別通常儲存在堆積積疊（Stack）上，並且大小是固定的。範例包括：
fn main() {
let x = 5;
let y = x; // 複製，x 和 y 都有效
println!("x: {}, y: {}", x, y);
}
基本型別（例如整數、浮點數、布林值等）都實作了 Copy，因此它們不遵循移動語意。
克隆（Cloning）
如果你需要複製堆積積分配的資料，可以使用 .clone() 方法：
fn main() {
let s1 = String::from("hello");
let s2 = s1.clone(); // 建立一個深層複製
println!("s1: {}, s2: {}", s1, s2);
}
克隆會明確地在記憶體中建立一個獨立的副本，從而避免與移動相關的問題。
借用與參考
Rust 允許借用（Borrowing）而不是轉移所有權。借用使你能夠在不放棄所有權的情況下傳遞資料。這是透過參考（References）實作的。
不可變借用（Immutable Borrowing）
參考（&T）允許對資料進行唯讀存取，而無需取得所有權：
fn print_length(s: &String) {
println!("Length: {}", s.len());
}
fn main() {
let s = String::from("hello");
print_length(&s); // 傳遞一個參考，所有權仍然屬於 s
}
你可以同時擁有對同一個資料的多個不可變借用，但不能同時存在可變借用。
可變借用（Mutable Borrowing）
可變參考（&mut T）允許修改資料，但每次只能有一個可變借用：
fn append_world(s: &mut String) {
s.push_str(" world");
}
fn main() {
let mut s = String::from("hello");
append_world(&mut s);
println!("{}", s); // 輸出 "hello world"
}
這個規則防止了資料競爭，確保了記憶體安全。
所有權與函式
當將值傳遞給函式時，所有權的移動或借用行為會影響函式內外的資料可用性。
函式中的所有權移動
如果函式接受一個非 Copy 型別的值作為引數，則所有權會移動到函式內部。這意味著在函式外部，原始變數將不再有效。
fn take_ownership(s: String) {
println!("{}", s);
}
fn main() {
let s = String::from("hello");
take_ownership(s);
// println!("{}", s); // 錯誤：s 的所有權已移動
}
函式中的借用
透過參考傳遞值允許函式存取資料，而無需取得所有權。這使得在函式外部仍然可以使用原始變數。
fn print_string(s: &String) {
println!("{}", s);
}
fn main() {
let s = String::from("hello");
print_string(&s);
println!("{}", s); // s 仍然有效
}
何時使用移動、複製或克隆？
選擇移動、複製或克隆取決於你的需求和資料型別。
- 移動：當你希望轉移所有權，並且不再需要原始變數時。
- 複製：當你的型別實作了
Copy特徵，並且你希望保留原始變數的副本時。 - 克隆：當你需要複製堆積積分配的資料，並且不希望原始變數受到修改影響時。
Rust 的所有權模型可能需要一些時間才能完全掌握，但它是 Rust 提供記憶體安全和高效能的關鍵。透過理解所有權、移動、複製和借用等概念，你可以編寫出安全與高效的 Rust 程式。深入理解這些概念將有助於你更好地利用 Rust 的強大功能，並避免常見的記憶體管理錯誤。
在 Rust 的世界裡，所有權（Ownership）機制是其最核心與獨特的特性之一。它賦予 Rust 在沒有垃圾回收機制（Garbage Collection，GC）的情況下，依然能夠實作記憶體安全（Memory Safety）的能力。理解所有權機制，是掌握 Rust 這門程式語言的關鍵。本文將探討 Rust 的所有權、移動（Move）、複製（Copy）、借用（Borrowing）以及生命週期（Lifetimes）等概念，幫助您寫出更高效、更安全的 Rust 程式碼。
變數所有權：Rust 的資源管理之道
在傳統的程式語言中，記憶體管理往往是開發者的一大挑戰。開發者需要手動分配和釋放記憶體，稍有不慎就可能導致記憶體洩漏或懸 dangling 指標（Dangling Pointer）等問題。而 Rust 透過所有權機制，在編譯時期就解決了這些問題。
每個 Rust 變數都有其所有權，當變數離開作用域（Scope）時，其擁有的資源會自動釋放。這就像是一種資源管理的責任鏈，確保每個資源都有明確的擁有者，並在不再需要時自動清理。
fn main() {
let s = String::from("hello"); // s 取得 "hello" 字串的所有權
// ... 使用 s
} // s 離開作用域，"hello" 字串的記憶體會被自動釋放
移動語意：所有權的轉移
當我們將一個變數指定給另一個變數時，所有權會發生轉移。這稱為移動（Move）。移動後，原變數不再有效，因為它已經失去了對資源的所有權。
fn main() {
let s1 = String::from("hello");
let s2 = s1; // s1 的所有權移動到 s2
// println!("{}", s1); // 錯誤！s1 不再有效
println!("{}", s2); // 正確，s2 擁有 "hello" 字串的所有權
}
這種設計避免了雙重釋放（Double Free）的問題，確保同一塊記憶體不會被多次釋放。
複製語意：資料的深層複製
如果我們希望同時擁有兩個變數，與它們都指向相同的資料，可以使用複製（Copy）。但並非所有型別都支援複製。預設情況下，Rust 會執行淺層複製（Shallow Copy），也就是隻複製指標，而不複製實際資料。這會導致兩個變數指向相同的記憶體位置，從而引發問題。
對於需要深層複製（Deep Copy）的型別，例如 String，我們可以使用 clone() 方法。
fn main() {
let s1 = String::from("hello");
let s2 = s1.clone(); // s1 的資料被深層複製到 s2
println!("s1 = {}, s2 = {}", s1, s2); // s1 和 s2 都有效
}
但需要注意的是，深層複製會產生額外的效能開銷，因此應謹慎使用。
借用規則：分享但不修改
有時候，我們希望在不轉移所有權的情況下，也能夠存取變數的資料。這時候就可以使用借用（Borrowing）。Rust 允許我們建立參考（Reference），參考就像是指向變數的指標，可以讓我們存取變數的資料，但不能修改它（除非是可變參考）。
Rust 有以下借用規則：
- 同一時間，只能有一個可變參考（Mutable Reference）。
- 同一時間，可以有多個不可變參考（Immutable Reference）。
- 可變參考和不可變參考不能同時存在。
這些規則確保了資料的一致性和避免資料競爭（Data Race）的問題。
fn main() {
let s = String::from("hello");
let r1 = &s; // 不可變參考
let r2 = &s; // 不可變參考
println!("{} and {}", r1, r2);
// let r3 = &mut s; // 錯誤！不能同時存在可變參考和不可變參考
let mut s2 = String::from("hello");
let r4 = &mut s2; // 可變參考
r4.push_str(", world!");
println!("{}", s2);
}
生命週期註解：確保參考的有效性
生命週期（Lifetimes）是 Rust 用來確保參考有效的機制。當我們建立參考時，Rust 編譯器會檢查參考的生命週期是否長於其指向的資料。如果參考的生命週期短於資料，就會發生懸 dangle 指標的問題。
為了讓編譯器能夠判斷參考的有效性，我們可以使用生命週期註解（Lifetime Annotations）。生命週期註解並不會改變參考的生命週期，而是用來告訴編譯器不同參考之間的生命週期關係。
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
fn main() {
let string1 = String::from("long string");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
println!("The longest string is {}", result);
}
// println!("The longest string is {}", result); //string2 離開作用域，result 變成懸 dangling 指標
}
在上面的例子中，<'a> 表示 x 和 y 具有相同的生命週期。這告訴編譯器，回傳的參考的生命週期必須與 x 和 y 中較短的那個相同。
Rust 的所有權機制是其記憶體安全的核心。透過所有權、移動、複製、借用和生命週期等概念，Rust 能夠在編譯時期就發現並避免許多常見的記憶體錯誤。雖然學習曲線較陡峭，但一旦掌握，您將能夠編寫出更安全、更高效的 Rust 程式碼。理解並善用 Rust 的所有權機制，才能真正發揮這門程式語言的強大威力，開發出可靠與高效的應用程式。
