Rust 基礎：資料型別、所有權、借用與流程控制

– 13 分鐘閱讀

Rust 的型別系統嚴謹且豐富，涵蓋了整數、浮點數數、布林值等基本型別，以及更進階的結構體、列舉和集合型別。所有權和借用機制是 Rust 的核心特性，它們確保了記憶體安全，同時避免了垃圾回收的效能損耗。理解這些概念對於編寫高效且安全的 Rust 程式至關重要。本文也涵蓋了 Rust 的流程控制，包含條件判斷、迴圈等，讓讀者瞭解如何在 Rust 中控制程式的執行流程。

整數型別

  • i8：帶符號的 8 位整數
  • i16：帶符號的 16 位整數
  • i32：帶符號的 32 位整數
  • i64：帶符號的 64 位整數
  • i128：帶符號的 128 位整數
  • isize：帶符號的架構大小整數（32 位或 64 位）

無符號整數型別

  • u8：無符號的 8 位整數
  • u16：無符號的 16 位整數
  • u32：無符號的 32 位整數
  • u64：無符號的 64 位整數
  • u128：無符號的 128 位整數
  • usize：無符號的架構大小整數（32 位或 64 位）

浮點數數型別

  • f32：32 位浮點數數
  • f64：64 位浮點數數

內容解密：

以上資料型別是 Rust 中的基本型別，根據不同的需求選擇合適的型別以確保程式的正確性和效率。例如，在需要儲存大資料時，選擇 i64 或 u64；在需要進行浮點數運算時，選擇 f32 或 f64。

圖表翻譯：

  flowchart TD
    A[整數型別] --> B[帶符號整數]
    A --> C[無符號整數]
    B --> D[i8, i16, i32, i64, i128, isize]
    C --> E[u8, u16, u32, u64, u128, usize]
    A --> F[浮點數數型別]
    F --> G[f32, f64]

此圖表展示了 Rust 中的資料型別分類，包括整數型別（帶符號和無符號）和浮點數數型別。

Rust 基礎概念：所有權和借用

Rust 的所有權系統是其最重要的特徵之一，讓開發者能夠安全地管理記憶體。以下是所有權和借用的基本概念：

所有權（Ownership）

在 Rust 中，每個值都有一個所有者（owner），所有者負責管理值的生命週期。當所有者離開作用域時，值就會被丟棄。

借用（Borrowing）

Rust 的借用系統允許開發者使用別人的值而不需要擁有它。借用可以是不可變的（immutable）或可變的（mutable）。

不可變借用（Immutable Borrowing）

不可變借用是指借用一個值而不允許修改它。這種借用是安全的，因為它不會修改原始值。

可變借用（Mutable Borrowing）

可變借用是指借用一個值並允許修改它。這種借用需要小心使用，因為它可能會修改原始值。

Guessing Game 範例

以下是 Guessing Game 範例的程式碼：

use rand::Rng;
use std::cmp::Ordering;

fn main() {
    // 問使用者輸入
    println!("請輸入 1-20 之間的數字：");

    // 建立一個新的空字串例項
    let mut input = String::new();

    // 讀取使用者輸入
    std::io::stdin().read_line(&mut input).expect("無法取得輸入");

    // 刪除空白字元並解析為整數
    let guess: i32 = input.trim().parse().expect("無法轉換為整數");

    // 產生隨機數字
    let mut rng = rand::thread_rng();
    let answer: i32 = rng.gen_range(1..20);

    // 比較猜測值和答案
    match guess.cmp(&answer) {
        Ordering::Greater => println!("太高了！"),
        Ordering::Less => println!("太低了！"),
        Ordering::Equal => println!("猜對了！"),
    }
}

這個範例展示瞭如何使用 Rust 的所有權和借用系統來管理記憶體和避免錯誤。

Ownership 的重要性

Ownership 是 Rust 的核心概念，它讓開發者能夠安全地管理記憶體。以下是 Ownership 的重要性：

  • 記憶體安全：Ownership 系統確保記憶體被正確地管理和釋放，避免記憶體洩漏和其他相關問題。
  • 避免 null 指標：Ownership 系統不允許 null 指標，這減少了程式碼中的錯誤和 bug。
  • 提高程式碼安全性：Ownership 系統確保程式碼是安全的，避免了記憶體相關的安全漏洞。

Rust 的記憶體管理

Rust 的記憶體管理與其他語言如 Python 或 Java 有所不同。Rust 不使用垃圾收集器（Garbage Collector），而是使用所有權（Ownership）和借用檢查器（Borrow Checker）來管理記憶體。

所有權和借用

在 Rust 中，所有權是指一個值的擁有權。當一個值被建立時，它會被分配給一個所有者。所有者可以是變數、函式或其他資料結構。當所有者離開作用域時，值會被丟棄。

借用是指對一個值的參照。借用可以是不可變的（&）或可變的（&mut）。當一個值被借用時，所有者仍然保持對值的擁有權，但借用者可以使用值。

let string = "Hi, who owns me?".to_string();
let borrowed_string = &string; // 借用 string
println!("{}", borrowed_string); // 輸出 "Hi, who owns me?"

移動和複製

當一個值被指定給另一個變數時，值會被移動到新的變數中。這意味著原始變數將不再擁有值。

let string = "Hi, who owns me?".to_string();
let owned_string = string; // 移動 string 到 owned_string
println!("{}", string); // 錯誤：string 已經被移動

如果想要保持原始變數的值，可以使用 clone() 方法來複製值。

let string = "Hi, who owns me?".to_string();
let owned_string = string.clone(); // 複製 string
println!("{}", string); // 輸出 "Hi, who owns me?"
println!("{}", owned_string); // 輸出 "Hi, who owns me?"

Copy 和 Clone 特徵

Rust 提供了 Copy 和 Clone 兩個特徵來控制值的複製行為。Copy 特徵表示值可以被複製，而 Clone 特徵表示值可以被複製，但需要手動實作。

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

let point = Point { x: 1, y: 2 };
let copied_point = point; // 複製 point
println!("{}", copied_point.x); // 輸出 1

瞭解複製和克隆的差異

在 Rust 中，Copy 和 Clone 是兩個不同的特性，它們都可以用來複製一個繫結的值，但是它們的行為和用法是不同的。Copy 是隱式的，而 Clone 是顯式的，需要使用 clone() 方法。

Copy 的特性

Copy 特性是用來複製一個繫結的值，它不會改變原始值的所有權。當你使用 Copy 時，Rust 會自動建立一個新的繫結，並將原始值的內容複製到新的繫結中。

Clone 的特性

Clone 特性是用來建立一個繫結的複製品，它會改變原始值的所有權。當你使用 clone() 方法時，Rust 會建立一個新的繫結，並將原始值的內容複製到新的繫結中。與 Copy 不同，clone() 方法需要顯式呼叫。

Reference Counter 的使用

Reference Counter (std::rc::Rc) 是一個用來計數繫結參照的工具。當你建立一個新的 Reference Counter 時，它會計數繫結的強參照數量。當強參照數量為 0 時，繫結會被釋放。

以下是使用 Reference Counter 的範例：

use std::rc::Rc;

fn main() {
    let owner = Rc::new(8); // 建立一個新的 Reference Counter
    println!("Owners: {}", Rc::strong_count(&owner)); // 輸出：1

    {
        println!("New closure");
        let owner2 = owner.clone(); // 克隆 owner
        println!("Owners: {}", Rc::strong_count(&owner)); // 輸出：2

        {
            println!("New closure");
            let owner3 = owner.clone(); // 克隆 owner
            println!("Owners: {}", Rc::strong_count(&owner)); // 輸出：3

            println!("Leaving closure, owner3 dropped");
        } // owner3 釋放

        println!("Owners: {}", Rc::strong_count(&owner)); // 輸出：2
        println!("Leaving closure, owner2 dropped");
    } // owner2 釋放

    println!("Owners: {}", Rc::strong_count(&owner)); // 輸出：1
} // owner 釋放

在這個範例中，我們建立了一個新的 Reference Counter owner，然後克隆它兩次，建立了 owner2 和 owner3。當我們離開 closure 時，owner2 和 owner3 會被釋放，強參照數量會減少。

Borrowing 規則

Borrowing 規則是 Rust 中的一個重要概念，它用來避免資料競爭和記憶體安全問題。以下是 Borrowing 規則的簡要概述：

  • &T: 不可變借用（Immutable Borrow）
  • 不可以改變借用的值
  • 只是一個指向繫結值的參照
  • &mut T: 可變借用（Mutable Borrow）
  • 可以改變借用的值
  • 需要顯式呼叫 mut 關鍵字

在 Rust 中，借用規則是用來確保資料安全和記憶體安全。它可以避免資料競爭和記憶體安全問題，讓你的程式更加穩定和可靠。

Rust 記憶體管理與借用檢查器

Rust 的記憶體管理是根據所有權和借用機制，確保記憶體的安全性和效率。借用檢查器（Borrow Checker）是 Rust 編譯器的一部分，負責在編譯時檢查程式碼是否符合借用規則。

借用規則

  1. 參照不得超出其所有者的生命週期：如果所有者被丟棄，則參照將指向無效的記憶體，導致段錯誤。
  2. 如果存在可變借用，則在同一範圍內不得存在其他參照：可變借用就像是一種互斥鎖，防止其他參照存取同一值。
  3. 如果不存在可變借用，則可以存在多個不可變借用：因為值不會被修改，多個不可變借用不會影響所有者。

指標型別

Rust 提供了多種指標型別，包括：

  • &：參照或安全指標，用於借用值。
  • *：解參照或原始指標，用於解參照指標。主要用於不安全程式碼。
  • Box：用於在堆積上分配值，擁有值的所有權。
  • Rc：用於參照計數，建立強參照，當參照計數達到 0 時，值將被丟棄。可以降級為弱參照。
// 示例：使用 Box 和 Rc
fn main() {
    // Box 示例
    let b = Box::new(10);
    println!("Box value: {}", b);

    // Rc 示例
    let rc = Rc::new(20);
    println!("Rc value: {}", rc);
}

Rust 的記憶體管理和控制流

Rust 是一種強調記憶體安全的語言，為了實作這一點，Rust 提供了多種工具和機制。其中，智慧指標（Smart Pointers）是一種重要的概念，能夠自動管理記憶體的分配和釋放。

智慧指標

Rust 提供了多種智慧指標，包括 Arc<T>、Cell<T> 和 RefCell<T>。這些智慧指標能夠根據不同的使用場景提供不同的記憶體管理策略。

Arc<T>

Arc<T> 是一個原子參照計數（Atomic Reference Counting）智慧指標。它能夠在多個執行緒之間安全地分享資料。當最後一個參照 Arc<T> 的指標被丟棄時，相關的記憶體將被釋放。

Cell<T>

Cell<T> 提供了內部可變性（Internal Mutability）給實作了 Copy 特性的型別。這意味著你可以在不需要 mut 參照的情況下修改資料。然而，這種方法需要小心使用，因為它可能會導致資料不一致。

RefCell<T>

RefCell<T> 也提供了內部可變性，但它不需要 Copy 特性。相反，它使用執行時鎖定（Runtime Locking）來確保安全性。這意味著當你試圖修改資料時，RefCell<T> 會檢查是否已經有其他參照正在修改資料，如果是，則會引發一個錯誤。

控制流

Rust 的控制流語法與 C 語法非常相似。邏輯運算子（Logic Operators）用於評估布林表示式，而條件運算子（Conditional Operators）用於比較值。

邏輯運算子

邏輯運算子包括 &&（和）、||（或）和 !（非）。這些運算子可以用於組合布林表示式。

// 邏輯運算子示例
let a = true && true;  // a = true
let b = true && false;  // b = false

條件運算子

條件運算子用於比較值，包括 ==（等於）、!=（不等於）、>（大於）、<（小於）、>=（大於或等於）和 <=（小於或等於）。

// 條件運算子示例
let c = 5 > 3;  // c = true
let d = 5 < 3;  // d = false

這些控制流語法元素是 Rust 程式設計的基礎，能夠幫助你構建複雜的邏輯和決策過程。

程式碼示例

以下是一個簡單的 Rust 程式，示範了智慧指標和控制流的使用：

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("最終計數：{}", *counter.lock().unwrap());
}

這個程式使用 Arc 和 Mutex 來安全地在多個執行緒之間分享一個計數器。每個執行緒都會鎖定計數器並將其值加 1。最終，主執行緒會等待所有子執行緒完成，並列印預出最終的計數值。

條件運運算元與流程控制

在程式設計中，條件運運算元和流程控制是非常重要的概念。它們允許我們根據特定條件執行不同的程式碼段。

邏輯運運算元

邏輯運運算元用於比較布林值（true 或 false）。以下是幾個常見的邏輯運運算元：

  • &&（和）：只有當兩個運算元都為 true 時，才傳回 true。
  • ||（或）：只要其中一個運算元為 true，就傳回 true。
  • !（非）：傳回運算元的相反值。

例如：

let a = true;
let b = false;

println!("{}", a && b); // false
println!("{}", a || b); // true
println!("{}", !a); // false
println!("{}", !b); // true

條件運運算元

條件運運算元用於比較值。以下是幾個常見的條件運運算元：

  • ==（等於）：比較兩個值是否相等。
  • <=（小於或等於）：比較兩個值是否小於或等於。
  • <（小於）：比較兩個值是否小於。
  • >=（大於或等於）：比較兩個值是否大於或等於。
  • >（大於）：比較兩個值是否大於。

例如：

let a = 5;
let b = 3;

println!("{}", a == b); // false
println!("{}", a <= b); // false
println!("{}", a < b); // false
println!("{}", a >= b); // true
println!("{}", a > b); // true

If/Else 陳述式

If/Else 陳述式用於根據條件執行不同的程式碼段。在 Rust 中，如果陳述式不需要括號。

let a = 5;

if a > 10 {
    println!("a 大於 10");
} else {
    println!("a 小於或等於 10");
}

在這個例子中，如果 a 大於 10，就會執行第一個程式碼段，否則就會執行第二個程式碼段。

內容解密：

如果陳述式是用於根據條件執行不同的程式碼段。在 Rust 中，如果陳述式不需要括號。這使得程式碼更簡潔、更容易閱讀。

圖表翻譯：

  flowchart TD
    A[開始] --> B[條件評估]
    B --> C[如果 true]
    C --> D[執行程式碼段 1]
    B --> E[如果 false]
    E --> F[執行程式碼段 2]

這個圖表展示瞭如果陳述式的流程。首先，評估條件，如果 true，就執行程式碼段 1，否則就執行程式碼段 2。

Rust 控制流程與迴圈

Rust 的控制流程是程式設計中用於控制程式執行流程的機制。控制流程可以決定程式的執行路徑、迴圈次數等。

If 判斷式

If 判斷式用於根據條件執行不同的程式碼。基本語法如下：

if 條件 {
    // 條件為 true 時執行的程式碼
} else {
    // 條件為 false 時執行的程式碼
}

例如：

if 5 > 3 {
    println!("TRUE");
} else {
    println!("FALSE");
}

這段程式碼會輸出 TRUE，因為 5 大於 3。

Else if 判斷式

Else if 判斷式用於在 if 判斷式之後新增另一個條件。基本語法如下：

if 條件1 {
    // 條件1為 true 時執行的程式碼
} else if 條件2 {
    // 條件1為 false 且條件2為 true 時執行的程式碼
} else {
    // 條件1和條件2都為 false 時執行的程式碼
}

例如：

if 5 < 3 {
    println!("TRUE");
} else if 7 > 5 {
    println!("ALSO TRUE");
} else {
    println!("FALSE");
}

這段程式碼會輸出 ALSO TRUE，因為 7 大於 5。

Match 判斷式

Match 判斷式用於根據多個條件執行不同的程式碼。基本語法如下：

match 變數 {
    模式1 => {
        // 變數匹配模式1時執行的程式碼
    },
    模式2 => {
        // 變數匹配模式2時執行的程式碼
    },
    _ => {
        // 變數不匹配任何模式時執行的程式碼
    }
}

例如：

let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Couldn't get input");
input = input.trim().to_lowercase();

match &input {
    "purple" => println!("Good choice"),
    "blue" => println!("Close to purple"),
    "red" => println!("Close to purple as well"),
    _ => println!("Why have you not picked purple?"),
}

這段程式碼會根據使用者輸入的顏色執行不同的程式碼。

迴圈

Rust 有三種迴圈：while、for 和 loop。While 迴圈和 for 迴圈用於執行程式碼直到某個條件為 true。Loop 迴圈用於執行程式碼直到手動停止。

While 迴圈

While 迴圈的基本語法如下：

let mut 變數 = 初始值;
while 條件 {
    // 條件為 true 時執行的程式碼
    變數 = 新值;
}

例如：

let mut sum = 0;
let mut i = 0;
while i < 50 {
    sum += i;
    i += 1;
}

這段程式碼會計算 0 到 49 的總和。

For 迴圈

For 迴圈的基本語法如下：

for 變數 in 範圍 {
    // 執行的程式碼
}

例如：

for i in 0..50 {
    println!("{}", i);
}

這段程式碼會輸出 0 到 49 的數字。

Loop 迴圈

Loop 迴圈的基本語法如下：

loop {
    // 執行的程式碼
}

例如：

loop {
    println!("Hello, world!");
}

這段程式碼會不斷輸出 Hello, world!，直到手動停止。

Rust 中的迴圈控制

Rust 的迴圈控制結構包括 loop、while 和 for。在本節中，我們將深入探討 for 迴圈的使用方法。

For 迴圈

for 迴圈在 Rust 中與 Python 中的使用方法相似。您可以使用 for 迴圈來遍歷一個可迭代的物件（例如向量）或一個範圍（例如 0..20）。

範例：遍歷向量

// 建立一個向量
let vector = vec![1, 3, 5, 7]; // type: Vec<i32>

// 遍歷向量並列印每個元素
for i in &vector {
    // i 是 type &i32
    println!("{}", i);
}
// 輸出：
// 1
// 3
// 5
// 7

在這個範例中，我們建立了一個向量 vector 並使用 for 迴圈來遍歷它。變數 i 的型別是 &i32，它代表向量中的每個元素。

範例：使用範圍

// 建立一個空的向量
let mut vector: Vec<i32> = Vec::new();

// 使用範圍推入元素到向量中
for i in 0..10 {
    vector.push(i);
}

// 建立另一個迴圈來列印每個元素
for i in 0..vector.len() {
    println!("Element => {} : Value => {}", i, vector[i]);
}
// 輸出：
// Element => 0 : Value => 0
// Element => 1 : Value => 1
// Element => 2 : Value => 2
// Element => 3 : Value => 3
// Element => 4 : Value => 4
// Element => 5 : Value => 5
// Element => 6 : Value => 6
// Element => 7 : Value => 7
// Element => 8 : Value => 8
// Element => 9 : Value => 9

在這個範例中，我們使用 for 迴圈來推入元素到向量中，然後使用另一個 for 迴圈來列印每個元素。

使用 continue 和 break 新增特殊條件

您可以使用 continue 和 break 關鍵字來新增特殊條件到您的迴圈中。continue 會跳過當前的迭代並繼續下一個迭代，而 break 會終止迴圈。

範例：使用 continue

for i in 0..10 {
    if i % 2 == 0 {
        continue;
    }
    println!("{}", i);
}
// 輸出：
// 1
// 3
// 5
// 7
// 9

在這個範例中，我們使用 continue 關鍵字來跳過偶數迭代。

範例：使用 break

for i in 0..10 {
    if i == 5 {
        break;
    }
    println!("{}", i);
}
// 輸出：
// 0
// 1
// 2
// 3
// 4

在這個範例中，我們使用 break 關鍵字來終止迴圈當 i 等於 5 的時候。

Rust 基礎語法與函式宣告

Rust 是一種強大的系統程式語言，提供了許多特性來幫助開發者編寫安全、效率高的程式碼。以下是 Rust 的一些基礎語法和函式宣告的介紹。

從底層實作到高階應用的全面檢視顯示，Rust 的資料型別、所有權系統、借用規則以及豐富的控制流程和智慧指標，共同構成了其強大的記憶體安全和效率保障。多維比較分析顯示，Rust 的所有權系統和借用檢查器雖然提升了記憶體安全性，但也增加了學習曲線和程式碼編寫的複雜度。對於習慣於帶有垃圾回收機制的語言的開發者而言，需要重新思考記憶體管理的策略。Rust 的嚴格編譯時檢查能有效避免許多常見的記憶體錯誤，例如懸空指標和資料競爭。然而，這也意味著開發者需要更精確地控制資料的生命週期和所有權轉移。從技術演進角度，Rust 對記憶體安全和效能的兼顧代表了系統程式語言的一個重要發展方向。對於重視效能和安全性的系統級開發，Rust 值得深入學習和應用。玄貓認為，Rust 的學習曲線雖然較陡峭，但其帶來的效能提升和安全性保障，使其在特定領域，例如嵌入式系統、作業系統和高效能運算等，具有顯著的優勢，值得長期投入。

玄貓

玄貓

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