Rust程式語言系統程式設計入門

Rust 作為一門系統程式語言，它在效能方面與 C/C++ 比肩，同時透過所有權和借用系統，提供更安全的記憶體管理機制。Rust 的型別系統在編譯時期就能有效捕捉許多錯誤，避免了執行時期的意外。對於需要高效能且注重安全性的系統級開發，Rust 提供了兼顧兩者的解決方案。其所有權系統確保每個值都只有一個擁有者，避免了懸空指標和資料競爭等問題，同時在編譯時期強制執行這些規則，無需額外的執行時開銷。此外，Rust 也提供了豐富的迭代器和集合處理功能，讓開發者能更有效率地操作資料。

為什麼選擇Rust？

Rust是一種系統程式語言，它提供了與C和C++相當的效能，但同時具備了更高層次的記憶體安全保證。Rust的設計目標是讓開發者能夠編寫出既快速又安全的程式碼。

型別安全

Rust的型別系統是其安全性的根本。透過嚴格的編譯時檢查，Rust能夠防止許多型別的錯誤，例如空指標解參照和資料競爭。Rust的型別系統還支援泛型程式設計，讓開發者能夠編寫出既靈活又安全的程式碼。

記憶體管理

Rust引入了獨特的所有權（Ownership）和借用（Borrowing）概念，以管理記憶體。這些機制確保了記憶體的安全存取，避免了常見的記憶體相關錯誤，如使用已釋放的記憶體。

並發程式設計

Rust提供了強大的並發程式設計支援。透過其所有權系統和型別系統，Rust能夠在編譯時檢查資料競爭，從而避免了許多並發程式設計中的常見錯誤。

Rust的基本型別

Rust提供了一系列的基本型別，包括整數、浮點數、布林值、字元等。這些基本型別是建構更複雜資料結構的基礎。

整數型別

Rust提供了多種整數型別，如i32、u32、i64等，以滿足不同的需求。這些型別具有不同的大小和符號，能夠用於各種整數運算。

浮點數型別

Rust支援f32和f64兩種浮點數型別，分別對應單精確度和雙精確度浮點數。這些型別適用於需要進行浮點數運算的場景。

布林型別

Rust的布林型別bool用於表示真或假的值。它在條件判斷和邏輯運算中扮演著重要角色。

字元型別

Rust中的char型別用於表示單個Unicode字元。它能夠處理多種語言的字元，提供了良好的國際化支援。

函式與模組

Rust的函式是組織程式碼的基本單位。透過定義函式，開發者能夠將程式碼模組化，提高可讀性和可維護性。

函式定義

在Rust中，函式使用fn關鍵字定義。函式可以接受引數並傳回值，能夠用於執行各種任務。

模組系統

Rust的模組系統允許開發者將程式碼組織成邏輯單元。透過模組，開發者能夠更好地管理大型專案，提高程式碼的可維護性。

錯誤處理

Rust提供了強大的錯誤處理機制，包括Result和panic!宏。這些機制幫助開發者有效地處理執行時錯誤，提高程式的健壯性。

Result型別

Result型別用於表示可能失敗的操作。它有兩個變體：Ok(value)表示成功，Err(error)表示失敗。

panic!宏

panic!宏用於表示不可還原的錯誤。當程式遇到無法繼續執行的情況時，可以使用panic!來終止執行。

結構體與列舉

Rust中的結構體（Struct）和列舉（Enum）是兩種重要的自定義資料型別。它們允許開發者根據需求建立複雜的資料結構。

結構體

結構體用於將多個值組合成一個單元。透過定義結構體，開發者能夠建立具有命名欄位的資料結構。

列舉

列舉允許開發者定義一個值可以是多個不同變體之一的型別。列舉在表示狀態或結果時非常有用。

並發與平行處理

Rust提供了對並發和平行處理的良好支援。透過其所有權系統和型別系統，Rust能夠確保並發程式的安全性。

執行緒

Rust中的執行緒用於實作並發執行。開發者可以使用標準函式庫中的執行緒API來建立和管理執行緒。

通道

通道（Channel）是Rust中用於執行緒間通訊的一種機制。它允許執行緒之間安全地傳遞資料。

Rust 程式語言中的迭代器與集合處理

Rust 語言提供了一套強大且靈活的迭代器機制，讓開發者能夠高效地處理各種資料集合。本篇文章將探討 Rust 中的迭代器實作、相關特徵（trait）以及如何有效地使用它們來處理資料。

迭代器基礎

在 Rust 中，迭代器是用來遍歷集合元素的關鍵工具。迭代器的核心特徵是 Iterator，它定義了取得集合中下一個元素的方法。透過實作 Iterator 特徵，開發者可以為自定義的資料結構建立迭代器。

建立迭代器

Rust 提供了多種方式來建立迭代器，包括：

1. 基本迭代方法：使用 iter() 和 iter_mut() 方法可以對集合進行唯讀或可變迭代。
2. IntoIterator 實作：許多集合型別都實作了 IntoIterator 特徵，允許它們被轉換成迭代器。
3. drain() 方法：該方法會消耗集合並傳回一個迭代器，同時清空原始集合。

迭代器擴充套件方法

Rust 的迭代器提供了豐富的擴充套件方法，讓資料處理變得更加方便。常見的擴充套件方法包括：

1. map() 和 filter()：用於對集合元素進行對映和過濾操作。
2. filter_map() 和 flat_map()：結合了對映和過濾功能，並且可以展平巢狀結構。
3. take() 和 skip()：用於限制迭代器的輸出數量或跳過特定數量的元素。

例項程式碼

let numbers = vec![1, 2, 3, 4, 5];
// 使用 map 將數字轉換為字串
let number_strs: Vec<String> = numbers.into_iter()
                                     .map(|n| n.to_string())
                                     .collect();

程式碼解析

1. 程式碼首先建立了一個包含數字的向量 numbers。
2. 使用 into_iter() 將向量轉換為消耗型迭代器。
3. 透過 map() 方法將每個數字轉換為對應的字串表示。
4. 最後使用 collect() 方法將結果收集到一個新的向量中。

自定義迭代器實作

開發者可以為自己的資料結構實作迭代器。以下是一個簡單的範例，展示如何為自定義二元樹實作迭代器：

1. 定義二元樹結構

struct BinaryTree<T> {
    value: T,
    left: Option<Box<BinaryTree<T>>>,
    right: Option<Box<BinaryTree<T>>>,
}

2. 實作迭代器

impl<T> IntoIterator for BinaryTree<T> {
    type Item = T;
    type IntoIter = BinaryTreeIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        BinaryTreeIter {
            stack: vec![self],
        }
    }
}

struct BinaryTreeIter<T> {
    stack: Vec<BinaryTree<T>>,
}

impl<T> Iterator for BinaryTreeIter<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.stack.pop().map(|node| {
            if let Some(left) = node.left {
                self.stack.push(*left);
            }
            if let Some(right) = node.right {
                self.stack.push(*right);
            }
            node.value
        })
    }
}

實作解析

1. 首先定義了二元樹的結構，包含節點值和左右子樹。
2. 實作 IntoIterator 特徵，將二元樹轉換為迭代器。
3. 自定義的 BinaryTreeIter 結構使用堆積疊來管理遍歷過程。
4. 在 next() 方法中實作了深度優先遍歷的邏輯。

效能考量

使用迭代器有以下幾個效能優勢：

1. 延遲計算：迭代器採用惰性求值，只有在需要時才會計算下一個值。
2. 避免不必要的記憶體組態：透過鏈式呼叫，可以減少中間結果的儲存需求。
3. 更好的快取區域性：連續的元素存取模式有助於提升快取命中率。

Rust 程式語言系統程式設計導論

Rust 是一種專為系統程式設計而設計的程式語言。系統程式設計涵蓋了廣泛的領域，包括作業系統、裝置驅動程式、檔案系統、資料函式庫、密碼學、媒體編解碼、記憶體管理、文字渲染、高階程式語言實作、網路、虛擬化、科學模擬和遊戲等。這些領域對資源的限制非常嚴格，每一個位元和每一個 CPU 週期都至關重要。

為何選擇 Rust？

對於已經熟悉系統程式設計的開發者來說，Rust 提供了一個新的選擇，讓他們能夠擺脫 C++ 的束縛。對於其他語言的開發者，如 C#、Java、Python 或 JavaScript，Rust 也提供了豐富的功能和安全性。

本文適合的讀者

本文適合所有對 Rust 和系統程式設計感興趣的開發者。無論您是經驗豐富的系統程式設計師，還是來自其他程式語言的開發者，本文都將為您提供深入的 Rust 知識和實踐經驗。

本文內容導航

本文首先介紹 Rust 的基礎知識，接著探討資料型別、所有權和參照等核心概念。後續章節涵蓋了語言基礎，如表示式、錯誤處理、crate 和模組、結構體、列舉和模式等。此外，本文還詳細介紹了 traits 和泛型、閉包和迭代器等進階主題，以及集合、字串和文書處理、輸入輸出、平行程式設計、巨集和不安全程式碼等。

本文使用慣例

本文採用以下排版慣例：

• 斜體字：表示新術語、URL、電子郵件地址、檔案名稱和檔案副檔名。
• 等寬字型：用於程式清單，以及在段落中參照程式元素，如變數或函式名稱、資料函式庫、資料型別、環境變數、陳述式和關鍵字。
• 等寬粗體：表示使用者應逐字輸入的命令或其他文字。
• 等寬斜體：表示應由使用者提供的數值或由上下文決定的數值所取代的文字。

系統程式設計的重要性

系統程式設計是當今軟體開發的基礎。從作業系統到裝置驅動程式，從檔案系統到資料函式庫，系統程式設計無處不在。Rust 提供了一種新的方式來進行系統程式設計，強調安全性和效能。

為何選擇 Rust？

在某些特定的環境中，例如 Rust 目標所瞄準的領域，要比競爭對手快上 10 倍甚至 2 倍，是一個決定成敗的關鍵因素。這就像是在硬體市場一樣，能夠決定一個系統在市場上的命運。

——Graydon Hoare

所有的電腦現在都是平行的… 平行程式設計就是程式設計。

——Michael McCool 等人，《結構化平行程式設計》

TrueType 解析器的缺陷曾被國家級攻擊者利用來進行監視；所有軟體都是對安全敏感的。

——Andy Wingo

系統程式語言在過去 50 年來已經有了長足的進步，自從我們開始使用高階語言來撰寫作業系統以來。但是有兩個問題特別難以解決：

• 撰寫安全的程式碼很困難。在 C 和 C++ 中正確地管理記憶體尤其困難。使用者們幾十年來一直受其困擾，出現了至少可以追溯到 1988 年 Morris 蠕蟲的安全漏洞。
• 撰寫多執行緒的程式碼非常困難，而這是利用現代機器能力的唯一方法。即使是經驗豐富的程式設計師也對平行程式碼保持謹慎：平行性可以引入廣泛的新型錯誤，並使普通的錯誤更難以重現。

於是，Rust 誕生了：一個安全、平行的語言，具備與 C 和 C++ 相媲美的效能。

Rust 的優勢

Rust 的設計目標是解決上述兩個問題。它透過獨特的所有權和借用系統，確保了記憶體安全，同時也提供了高效率的平行程式設計能力。這些特徵使得 Rust 成為系統程式設計的理想選擇。

為什麼 Rust 能夠提供記憶體安全？

Rust 的所有權系統保證了每一塊記憶體都有一個明確的擁有者，當這個擁有者不再需要這塊記憶體時，Rust 就會自動釋放它。這樣就避免了 C 和 C++ 中常見的記憶體洩漏和野指標問題。

Rust 如何支援平行程式設計？

Rust 的型別系統和所有權模型使得撰寫平行程式碼變得更加容易。Rust 的編譯器會在編譯時期檢查平行程式碼的安全性，從而避免了許多常見的平行錯誤。

為什麼選擇Rust？

Rust是一種由Mozilla和貢獻者社群共同開發的新型系統程式語言。與C和C++相同，Rust讓開發者能夠精細控制記憶體的使用，並且保持語言原始操作與其執行機器之間的密切關係，幫助開發者預期其程式碼的成本。Rust與Bjarne Stroustrup在其論文“Abstraction and the C++ Machine Model”中對C++的設想相吻合：

一般來說，C++的實作遵循零開銷原則：你不使用的東西，你不會為它付出代價。並且：你使用的東西，你無法手動編寫得更好。

Rust在這些基礎上增加了自身的目標：記憶體安全和可靠的平行處理。實作這些承諾的關鍵是Rust新穎的所有權、移動和借用系統，在編譯時進行檢查，並精心設計以補充Rust靈活的靜態型別系統。所有權系統為每個值建立了明確的生命週期，使得核心語言中不需要垃圾收集，並能夠為管理其他資源（如通訊端和檔案控制程式碼）提供健全但靈活的介面。移動操作將值從一個所有者轉移到另一個所有者，而借用允許程式碼暫時使用一個值而不會影響其所有權。由於許多程式設計師以前從未遇到過這些特性，我們將在第4章和第5章中詳細解釋它們。

這些所有權規則也構成了Rust可靠的平行處理模型的基礎。大多數語言將互斥鎖與其要保護的資料之間的關係留給註解；Rust實際上可以在編譯時檢查您的程式碼是否在存取資料時鎖定了互斥鎖。大多數語言告誡您在將資料結構交給另一個執行緒後不要再使用它；Rust檢查您是否這樣做了。Rust能夠在編譯時防止資料競爭。

Rust不是一種真正的物件導向語言，儘管它具有一些物件導向的特性。Rust也不是一種函式式語言，儘管它確實傾向於使計算結果的影響更加明確，就像函式式語言一樣。Rust在一定程度上類別似於C和C++，但這些語言中的許多慣用法並不適用，因此典型的Rust程式碼並不深深地類別似於C或C++程式碼。最好是保留對Rust這種語言的判斷，直到您對該語言感到舒適後再做評判。

為了在真實環境中獲得對設計的反饋，Mozilla使用Rust開發了Servo，一種新的網頁瀏覽器引擎。Servo的需求和Rust的目標非常匹配：瀏覽器必須表現良好並安全地處理不受信任的資料。Servo使用Rust的安全平行處理來充分利用機器資源執行原本難以在C或C++中平行化的任務。事實上，Servo和Rust是一起成長的，Servo使用了最新的新語言特性，而Rust則根據Servo開發者的反饋進行了演進。

型別安全

Rust是一種型別安全的語言。但我們所說的“型別安全”是什麼意思？安全聽起來很好，但我們到底被保護免受什麼？

以下是C程式語言1999年標準（稱為C99）對未定義行為的定義： 未定義行為 在使用非可移植或錯誤的程式結構或錯誤資料時出現的行為，對此國際標準沒有任何要求

考慮以下C程式：

int main(int argc, char **argv) {
    unsigned long a[1];
    a[3] = 0x7ffff7b36cebUL;
    return 0;
}

根據C99標準，因為該程式存取了陣列a末端以外的元素，所以其行為是未定義的，這意味著它可以做任何事情。當我們在Jim的膝上型電腦上執行這個程式時，它產生了以下輸出：

undef: Error: .netrc file is readable by others.
undef: Remove password or make file unreadable by others.

然後它當機了。Jim的膝上型電腦甚至沒有.netrc檔案。如果你自己嘗試，可能會做完全不同的事情。

C編譯器為這個main函式產生的機器碼恰好將陣列a放在堆積疊上距離傳回位址三個字的位置，因此將0x7ffff7b36cebUL儲存在a[3]中會改變main的可憐傳回位址，使其指向C標準函式庫中查詢.netrc檔案密碼的程式碼。當main傳回時，執行繼續不在main的呼叫者中，而是在這些行的機器碼中：

warnx(_("Error: .netrc file is readable by others."));
warnx(_("Remove password or make file unreadable by others."));
goto bad;

在允許陣列參照影響後續傳回陳述式的行為方面，C編譯器完全符合標準。未定義的操作不僅會產生未指定的結果：它被允許導致程式做任何事情。

C99標準授予編譯器這種全權，以便它可以產生更快的程式碼。編譯器不必負責檢測和處理奇怪的情況，而是假設程式設計師會正確地編寫程式碼。這種方法使得編譯器能夠最佳化程式碼，但也意味著程式設計師必須非常小心，以避免未定義的行為。

內容解密：

此段落主要闡述了C語言中的未定義行為及其對程式執行的影響。未定義行為是指當程式使用非可移植或錯誤的程式結構或錯誤資料時出現的行為，標準對此沒有任何要求。這種行為可能導致不可預期的結果，甚至使程式當機。範例中的C程式存取了陣列邊界以外的元素，這是一種未定義行為，導致了不可預期的輸出和當機。這凸顯了型別安全的重要性，以及Rust透過其所有權和借用系統如何避免這種問題。

程式碼解析

原始C程式碼

int main(int argc, char **argv) {
    unsigned long a[1];
    a[3] = 0x7ffff7b36cebUL;
    return 0;
}

內容解密：

1. 此C程式定義了一個main函式，包含一個大小為1的無符號長整數陣列a。
2. 程式試圖存取並修改a[3]，這是陣列邊界以外的元素。
3. 這種存取是未定義行為，因為它超出了陣列的有效索引範圍（對於大小為1的陣列，有效索引只有0）。
4. 未定義行為可能導致各種不可預期的結果，包括更改記憶體中與陣列相鄰儲存的值。
5. 在給定的範例執行中，這種未定義行為意外地修改了傳回位址，導致程式在傳回時跳轉到意外的程式碼位置執行。
6. 最終，這導致了不可預期的輸出和程式當機。