Rust向量

向量是一種單一數據結構,可以在內存中彼此相鄰地存儲多個值。 當有一個專案列表(例如:購物車中的資料項目)時,向量很有用。

要點:

  • 向量用於存儲相同類型的值。
  • 向量由Vec <T>表示。
  • Vec <T>由標準庫提供,它可以保存任何類型的數據,其中T確定向量的類型。
  • 向量的數據在堆上分配。
  • 向量是一個可增長的數組意味著可以在運行時添加新元素。

Vec <T> :當向量保持特定類型時,它在角括弧中表示。

如何創建向量?

可以使用Vec::new()函數創建向量,參考以下示例代碼 :

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

在上面的聲明中,vi32類型的向量,它是使用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("zaixian"))];
     for i in v
    {
       println!("{:?}",i);
     }
}

執行上面示例代碼,得到以下結果 -

A(5)
B(10.7)
C(zaixian)

在向量中使用枚舉的優點:

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

上一篇: Rust use關鍵字引用模組 下一篇: Rust字串