橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Rust向量

    向量是一种单一数据结构，可以在内存中彼此相邻地存储多个值。 当有一个项目列表(例如：购物车中的数据项)时，向量很有用。

    要点：

    • 向量用于存储相同类型的值。
    • 矢量由Vec <T>表示。
    • Vec <T>由标准库提供，它可以保存任何类型的数据，其中T确定向量的类型。
    • 向量的数据在堆上分配。
    • 向量是一个可增长的数组意味着可以在运行时添加新元素。

    Vec <T> ：当向量保持特定类型时，它在角括号中表示。

    如何创建向量？

    可以使用Vec::new()函数创建向量，参考以下示例代码 ：

    1. Let v : Vec<i32> = Vec::new();
    2. Rust

    在上面的声明中，v是i32类型的向量，它是使用Vec::new() 函数创建的。

    还有另一种创建向量的方法：

    Rust提供vec! 用于创建向量并保存提供的值的宏。

    例如：

    1. let v = vec![10,20,30,40,50];
    2. Rust

    注意：如果想重复向量的初始值，那么还有另一种实现vec的方法：

    1. let v = vec![2 ; i];
    2. Rust

    在上面的声明中，向量v是使用包含值2,i次的向量宏创建的。

    访问元素

    可以使用下标运算符[]访问向量的特定元素。

    通过下面一个例子来理解：

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

    执行上面示例代码，得到以下结果 - 

    1. first element of a vector is :20
    2. Second element of a vector is :30
    3. Third element of a vector is :40
    4. Fourth element of a vector is :50
    5. Shell

    访问向量元素的第二种方法是使用get(index)方法，将vector的索引作为参数传递，并返回Option <＆t>类型的值。

    看下面一个示例代码 - 

    1. fn value(n:Option<&i32>)  
    2. {  
    3.     match n  
    4.     {  
    5.         Some(n)=>println!("Fourth element of a vector is {}",n),  
    6.         None=>println!("None"),  
    7.     }  
    8. }  
    9. fn main()  
    10. {  
    11.     let v =vec![20,30,40,50];  
    12.     let a: Option<&i32>=v.get(3);  
    13.     value(a);  
    14. }
    15. Rust

    执行上面示例代码，得到以下结果 - 

    1. Fourth element of a vector is 50
    2. Shell

    在上面的示例中，get()方法用于访问向量的第四个元素。

    []和get()方法的区别：

    当使用[]运算符访问不存在的元素时，它会导致程序发生混乱。 因此，当尝试访问不存在的元素时，程序就会崩溃。 如果尝试使用get()方法访问该元素，则它返回None而不会发生崩溃。

    通过下面一个例子来理解这一点：

    • get(index)函数
    1. fn value(n:Option<&i32>)  
    2. {  
    3.  match n  
    4.  {  
    5.    Some(n)=>println!("Fourth element of a vector is {}",n),  
    6.    None=>println!("None"),  
    7.  }  
    8. }  
    9. fn main()  
    10. {  
    11.     let v =vec![20,30,40,50];  
    12.     let a: Option<&i32>=v.get(7);  
    13.     value(a);  
    14. }
    15. Rust

    执行上面示例代码，得到以下结果 - 

    1. None
    2. Shell
    • []运算符
    1. fn main()  
    2. {  
    3.     let v =vec![20,30,40,50];  
    4.     println!("{}",v[8]);  
    5. }
    6. Rust

    执行上面示例代码，得到以下结果 -

    迭代向量中的值

    如果想要访问向量的每个元素，那么可以迭代向量的元素，而不是使用索引来访问向量的特定元素。

    可以使用for循环来迭代可变或不可变的引用。

    下面来看一个不可变引用的简单示例：

    1. fn main()  
    2. {  
    3.     let v =vec![20,30,40,50];  
    4.     print!("Elements of vector are :");  
    5.     for i in v  
    6.     {  
    7.         print!("{} ",i);  
    8.     }  
    9. }
    10. Rust

    执行上面示例代码，得到以下结果 - 

    1. Elements of vector are :20 30 40 50
    2. Shell

    下面来看一个可变引用的简单示例：

    1. fn main()  
    2. {  
    3.     let mut v =vec![20,30,40,50];  
    4.     print!("Elements of vector are :");  
    5.     for i in &mut v  
    6.     {  
    7.         *i+=20;  
    8.         print!("{} ",i);  
    9.     }  
    10. }
    11. Rust

    执行上面示例代码，得到以下结果 - 

    1. Elements of vector are :20 30 40 50
    2. Shell

    在上面的例子中，改变向量的值。 因此，向量是可变参考。 在i变量之前使用引用运算符*来获取向量v的值。

    更新矢量

    当创建向量时，使用push()方法将元素插入到向量中。 push()在向量的末尾插入新元素。

    下面来看看一个简单的例子：

    1. fn main()  
    2. {  
    3.   let mut v=Vec::new();  
    4.   v.push('j');  
    5.   v.push('a');  
    6.   v.push('v');  
    7.   v.push('a');  
    8.   for i in v  
    9.   {  
    10.     print!("{}",i);  
    11.   }  
    12. }
    13. Rust

    执行上面示例代码，得到以下结果 - 

    1. java
    2. Shell

    在上面的示例中，push()函数用于在运行时将元素插入向量中。 向量v是可变的，这样也可以改变向量的值。

    删除矢量

    当向量超出范围时，它会自动删除或从内存中释放。通过一个简单的场景来理解这一点：

    1. fn main()  
    2. {  
    3.    let v = !vec[30,40,50];  
    4. } # => v 在这里被释放，因为它超出了范围。
    5. Rust

    在上面的场景中，当向量超出范围时释放向量意味着将移除向量中存在的所有元素。

    使用Enum存储多种类型

    向量可以存储相同类型的元素，这是向量的一个很大的缺点。 枚举是一种自定义数据类型，它包含相同枚举名称下的各种类型的变体。 当想要将元素存储在不同类型的向量中时，使用枚举类型。

    下面通过一个例子来理解这一点：

    1. #[derive(Debug)]  
    2. enum Values {  
    3.    A(i32),  
    4.    B(f64),   
    5.    C(String),  
    6. }  
    7.  
    8. fn main()   
    9. {  
    10.      let v = vec![Values::A(5),   
    11.      Values::B(10.7),Values::C(String::from("Yiibai"))];  
    12.      for i in v  
    13.     {  
    14.        println!("{:?}",i);  
    15.      }  
    16. }
    17. Rust

    执行上面示例代码，得到以下结果 - 

    1. A(5)
    2. B(10.7)
    3. C(Yiibai)
    4. Shell

    在向量中使用枚举的优点：

    • Rust在编译时知道向量元素的类型，以确定每个元素需要多少内存。
    • 当向量由一个或多个类型的元素组成时，对元素执行的操作将导致错误，但使用带有匹配的枚举将确保可以在运行时处理每个可能的情况。

    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140