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]);  
}

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

Rust向量

迭代向量中的值

如果想要訪問向量的每個元素,那麼可以迭代向量的元素,而不是使用索引來訪問向量的特定元素。

可以使用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在編譯時知道向量元素的類型,以確定每個元素需要多少內存。
  • 當向量由一個或多個類型的元素組成時,對元素執行的操作將導致錯誤,但使用帶有匹配的枚舉將確保可以在運行時處理每個可能的情況。
0 條評論,你可以發表評論,我們會進行改進
Comment author placeholder