Rust向量 - tw511教學網

向量是一種單一資料結構，可以在記憶體中彼此相鄰地儲存多個值。當有一個專案列表(例如：購物車中的資料項)時，向量很有用。

要點：

向量用於儲存相同型別的值。
向量由Vec <T>表示。
Vec <T>由標準庫提供，它可以儲存任何型別的資料，其中T確定向量的型別。
向量的資料在堆上分配。
向量是一個可增長的陣列意味著可以在執行時新增新元素。

Vec <T> ：當向量保持特定型別時，它在角括號中表示。

如何建立向量？

可以使用Vec::new()函式建立向量，參考以下範例程式碼：

Let v : Vec<i32> = Vec::new();

在上面的宣告中，v是i32型別的向量，它是使用Vec::new() 函式建立的。

還有另一種建立向量的方法：

Rust提供vec! 用於建立向量並儲存提供的值的巨集。

例如：

let v = vec![10,20,30,40,50];

注意：如果想重複向量的初始值，那麼還有另一種實現vec的方法：

let v = vec![2 ; i];

在上面的宣告中，向量v是使用包含值2,i次的向量巨集建立的。

存取元素

可以使用下標運算子[]存取向量的特定元素。

通過下面一個例子來理解：

fn main()  
{  
    let v =vec![20,30,40,50];  
    println!("first element of a vector is :{}",v[0]);  
    println!("Second element of a vector is :{}",v[1]);  
    println!("Third element of a vector is :{}",v[2]);  
    println!("Fourth element of a vector is :{}",v[3]);  
}

執行上面範例程式碼，得到以下結果 -

first element of a vector is :20
Second element of a vector is :30
Third element of a vector is :40
Fourth element of a vector is :50

存取向量元素的第二種方法是使用get(index)方法，將vector的索引作為引數傳遞，並返回Option <＆t>型別的值。

看下面一個範例程式碼 -

fn value(n:Option<&i32>)  
{  
    match n  
    {  
        Some(n)=>println!("Fourth element of a vector is {}",n),  
        None=>println!("None"),  
    }  
}  
fn main()  
{  
    let v =vec![20,30,40,50];  
    let a: Option<&i32>=v.get(3);  
    value(a);  
}

執行上面範例程式碼，得到以下結果 -

Fourth element of a vector is 50

在上面的範例中，get()方法用於存取向量的第四個元素。

[]和get()方法的區別：

當使用[]運算子存取不存在的元素時，它會導致程式發生混亂。因此，當嘗試存取不存在的元素時，程式就會崩潰。如果嘗試使用get()方法存取該元素，則它返回None而不會發生崩潰。

通過下面一個例子來理解這一點：

get(index)函式

fn value(n:Option<&i32>)  
{  
 match n  
 {  
   Some(n)=>println!("Fourth element of a vector is {}",n),  
   None=>println!("None"),  
 }  
}  
fn main()  
{  
    let v =vec![20,30,40,50];  
    let a: Option<&i32>=v.get(7);  
    value(a);  
}

執行上面範例程式碼，得到以下結果 -

None

[]運算子

fn main()  
{  
    let v =vec![20,30,40,50];  
    println!("{}",v[8]);  
}

執行上面範例程式碼，得到以下結果 -

疊代向量中的值

如果想要存取向量的每個元素，那麼可以疊代向量的元素，而不是使用索引來存取向量的特定元素。

可以使用for迴圈來迭代可變或不可變的參照。

下面來看一個不可變參照的簡單範例：

fn main()  
{  
    let v =vec![20,30,40,50];  
    print!("Elements of vector are :");  
    for i in v  
    {  
        print!("{} ",i);  
    }  
}

執行上面範例程式碼，得到以下結果 -

Elements of vector are :20 30 40 50

下面來看一個可變參照的簡單範例：

fn main()  
{  
    let mut v =vec![20,30,40,50];  
    print!("Elements of vector are :");  
    for i in &mut v  
    {  
        *i+=20;  
        print!("{} ",i);  
    }  
}

執行上面範例程式碼，得到以下結果 -

Elements of vector are :20 30 40 50

在上面的例子中，改變向量的值。因此，向量是可變參考。在i變數之前使用參照運算子*來獲取向量v的值。

更新向量

當建立向量時，使用push()方法將元素插入到向量中。 push()在向量的末尾插入新元素。

下面來看看一個簡單的例子：

fn main()  
{  
  let mut v=Vec::new();  
  v.push('j');  
  v.push('a');  
  v.push('v');  
  v.push('a');  
  for i in v  
  {  
    print!("{}",i);  
  }  
}

執行上面範例程式碼，得到以下結果 -

java

在上面的範例中，push()函式用於在執行時將元素插入向量中。向量v是可變的，這樣也可以改變向量的值。

刪除向量

當向量超出範圍時，它會自動刪除或從記憶體中釋放。通過一個簡單的場景來理解這一點：

fn main()  
{  
   let v = !vec[30,40,50];  
} # => v 在這裡被釋放，因為它超出了範圍。

在上面的場景中，當向量超出範圍時釋放向量意味著將移除向量中存在的所有元素。

使用Enum儲存多種型別

向量可以儲存相同型別的元素，這是向量的一個很大的缺點。列舉是一種自定義資料型別，它包含相同列舉名稱下的各種型別的變體。當想要將元素儲存在不同型別的向量中時，使用列舉型別。

下面通過一個例子來理解這一點：

#[derive(Debug)]  
enum Values {  
   A(i32),  
   B(f64),   
   C(String),  
}  

fn main()   
{  
     let v = vec![Values::A(5),   
     Values::B(10.7),Values::C(String::from("Yiibai"))];  
     for i in v  
    {  
       println!("{:?}",i);  
     }  
}

執行上面範例程式碼，得到以下結果 -

A(5)
B(10.7)
C(Yiibai)

在向量中使用列舉的優點：

Rust在編譯時知道向量元素的型別，以確定每個元素需要多少記憶體。
當向量由一個或多個型別的元素組成時，對元素執行的操作將導致錯誤，但使用帶有匹配的列舉將確保可以在執行時處理每個可能的情況。