橘子味的心
标题: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("Yiibai"))];  
     for i in v  
    {  
       println!("{:?}",i);  
     }  
}

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

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

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

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

分类