如何使用Rust的向量存儲值列表

更新時間：2025年02月26日 11:07:22 作者：Hello.Reader

本文介紹了在Rust中使用向量存儲值列表的方法,包括創(chuàng)建、更新、讀取、遍歷、存儲多種類型以及內存釋放等方面,向量是Rust中常用且強大的集合類型,熟練掌握其用法有助于編寫高效且安全的代碼

1. 創(chuàng)建新的向量

Rust 提供了兩種常用方式來創(chuàng)建向量：

使用 Vec::new

當你需要創(chuàng)建一個空的向量時，可以調用 Vec::new。

注意，由于向量中還沒有元素，編譯器無法自動推斷向量中元素的類型，這時通常需要添加類型注解。

例如：

fn main() {
    // 創(chuàng)建一個空的 Vec<i32>
    let mut v: Vec<i32> = Vec::new();

    // 向向量中添加元素
    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);

    println!("Vector: {:?}", v);
}

使用 vec! 宏

如果你希望一開始就初始化向量并指定初始值，可以使用 vec! 宏。

Rust 會根據(jù)給定的初始值自動推導向量元素的類型：

fn main() {
    // 創(chuàng)建一個包含初始值 1, 2, 3 的向量，類型會被推斷為 Vec<i32>
    let v = vec![1, 2, 3];

    println!("Vector: {:?}", v);
}

2. 更新向量

向量是動態(tài)大小的數(shù)據(jù)結構，可以通過調用 push 方法將新的元素添加到向量中。

需要注意的是，如果想要修改向量的內容，變量必須聲明為可變（mut）：

fn main() {
    let mut v = vec![1, 2, 3];

    // 添加元素到向量末尾
    v.push(4);
    v.push(5);

    println!("Updated vector: {:?}", v);
}

3. 讀取向量中的元素

讀取向量元素主要有兩種方法：使用索引語法和使用 get 方法。

3.1 使用索引語法

使用索引語法可以直接獲取向量中指定位置的元素。

例如：

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    let third: &i32 = &v[2]; // 注意：索引從 0 開始，所以索引 2 表示第三個元素
    println!("The third element is: {}", third);
}

注意：如果索引超出向量范圍（例如訪問一個不存在的元素），使用索引語法會導致程序 panic，從而崩潰。

3.2 使用 get 方法

get 方法會返回一個 Option<&T>，在訪問超出范圍時返回 None 而不是 panic，從而可以通過匹配（match）或其他方式來安全處理這種情況：

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    // 試圖獲取索引為 100 的元素
    match v.get(100) {
        Some(value) => println!("The element is: {}", value),
        None => println!("There is no element at index 100."),
    }
}

4. 向量與借用檢查器

Rust 的借用規(guī)則保證了對向量元素的引用安全。

舉個例子，如果我們在持有某個元素的不可變引用時嘗試修改向量，就會觸發(fā)借用檢查器報錯：

fn main() {
    let mut v = vec![1, 2, 3];

    // 獲取第一個元素的不可變引用
    let first = &v[0];
    // 嘗試向向量中添加一個新元素
    // v.push(4); // 這行代碼會導致編譯錯誤，因為不可變引用和可變操作不能共存

    println!("The first element is: {}", first);
}

原因在于：向量在內存中是連續(xù)存儲的，添加新元素可能會導致內存重新分配，進而使已有的引用失效。借用檢查器可以在編譯期間捕捉到這種潛在的安全問題。

5. 遍歷向量

遍歷向量通常使用 for 循環(huán)?？梢赃x擇不可變遍歷或者可變遍歷以修改元素。

5.1 不可變遍歷

下面的代碼演示了如何通過不可變引用遍歷向量中的每個元素并打印出來：

fn main() {
    let v = vec![100, 32, 57];

    for i in &v {
        println!("The value is: {}", i);
    }
}

5.2 可變遍歷

如果需要修改向量中的每個元素，則可以通過可變引用來遍歷：

fn main() {
    let mut v = vec![100, 32, 57];

    for i in &mut v {
        // 使用解引用操作符 * 來修改引用指向的值
        *i += 50;
    }

    println!("Modified vector: {:?}", v);
}

6. 使用枚舉存儲不同類型的值

向量要求所有元素必須是相同類型的，但在某些情況下，你可能需要在同一個向量中存儲不同類型的值。為了解決這一問題，可以定義一個枚舉，將所有可能的類型都作為枚舉的不同變體，然后將枚舉實例存儲在向量中：

// 定義一個枚舉，表示可能出現(xiàn)的不同類型
enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

fn main() {
    // 創(chuàng)建一個存儲 SpreadsheetCell 枚舉的向量
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Float(10.12),
        SpreadsheetCell::Text(String::from("blue")),
    ];

    // 遍歷向量，并根據(jù)每個枚舉的變體進行匹配處理
    for cell in row {
        match cell {
            SpreadsheetCell::Int(value) => println!("Integer: {}", value),
            SpreadsheetCell::Float(value) => println!("Float: {}", value),
            SpreadsheetCell::Text(text) => println!("Text: {}", text),
        }
    }
}

這種方式確保了所有向量中的值都屬于同一類型（即枚舉類型），同時允許我們存儲不同“實際”類型的值，并通過 match 語句在編譯時檢查每個可能的情況。

7. 向量的內存釋放

Rust 中的向量在超出作用域后會自動釋放，向量中的所有元素也會隨之被 drop（銷毀）。這一機制確保了內存的自動回收。

例如：

fn main() {
    {
        let v = vec![1, 2, 3, 4];
        // 在這里 v 以及其中的值都是有效的
        println!("Vector inside scope: {:?}", v);
    } // 離開作用域后，v 自動被 drop，內存被釋放

    // 這里 v 不再有效
}

借用檢查器同樣會確保在向量被 drop 之后，不再存在對其中元素的有效引用。

總結

本文介紹了如何在 Rust 中使用向量來存儲值列表，包括以下幾個方面：

創(chuàng)建向量：使用 Vec::new 創(chuàng)建空向量或使用 vec! 宏初始化向量，并掌握類型推斷與顯式注解的區(qū)別。
更新向量：通過 push 方法向向量添加元素，理解可變性的重要性。
讀取向量元素：比較索引語法和 get 方法的優(yōu)缺點，特別是處理越界訪問時的區(qū)別。
遍歷向量：演示如何使用 for 循環(huán)對向量進行不可變和可變遍歷，并說明了使用解引用操作符來修改元素的方式。
存儲多種類型：通過定義枚舉來將不同類型的值統(tǒng)一存儲在一個向量中，并利用 match 語句在編譯時進行檢查。
向量的釋放：說明向量在超出作用域后會自動釋放，同時向量中的元素也會被 drop，從而確保內存安全。