Rust什么是向量？向量的用法

本文概述

• 如何创建向量？
• 访问元素
• []＆get()方法之间的区别
• 遍历向量中的值
• 更新向量
• 删除向量
• 使用枚举存储多种类型

向量是一个单一的数据结构, 使你可以在内存中一个接一个地存储多个值。当我们具有物品清单(例如购物车中的物品)时, 向量很有用。

重要事项：

• 向量用于存储相同类型的值。
• 向量由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];

在上面的声明中, 向量v是使用向量宏创建的, 即vec!。对于vec！, Rust自动推断向量v的类型为Vec <i32>, 因为向量宏包含整数值。

注意：如果我们要重复向量的初始值, 那么还有另一种实现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)方法, 将向量的索引作为参数传递, 并返回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且不会出现惊慌。

让我们通过一个例子来理解这一点：

• 获取(索引)

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’变量之前使用dereference(*)运算符来获取向量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 is freed here as it goes out of the scope.

在上述情况下, 向量超出范围将被释放, 这意味着向量中存在的所有元素都将被删除。

使用枚举存储多种类型

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

让我们通过一个例子来理解这一点：

#[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("srcmini"))];
     for i in v
    {
	   println!("{:?}", i);
     }
}

输出

A(5)
B(10.7)
C(srcmini)

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

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