Rust向量(Vectors)是什么？

向量是单个数据结构，使您可以在存储器中存储多个值。要点：向量用于存储相同类型的值。向量由Vec <T>表示。 Vec <T>由标准库提供，该库可以保存任何类型的数据，其中T确定向量的

如何学习Rust向量(Vectors)？

学习Rust向量(Vectors)建议从基础概念开始，逐步深入。本教程提供了完整的Rust向量(Vectors)入门指南，包含理论讲解和实践代码示例。建议按照教程顺序学习，并通过实际操作加深理解。

Rust向量(Vectors)有什么实际应用？

Rust向量(Vectors)在实际开发中有广泛应用。掌握Rust向量(Vectors)可以帮助您更好地完成Rust相关的开发任务，提升编程技能和工作效率。

Rust向量(Vectors)

Q: Rust向量(Vectors)是什么？

向量是单个数据结构，使您可以在存储器中存储多个值。要点： 向量用于存储相同类型的值。 向量由Vec &lt;T&gt;表示。 Vec &lt;T&gt;由标准库提供，该库可以保存任何类型的数据，其中T确定向量的

超级访谈：对话玉伯

物联网开发实战

爱上跑步

向量是单个数据结构，使您可以在存储器中存储多个值。

要点:

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

Vec<T>: 当向量拥有特定类型时，则将其显示在尖括号中。

创建向量

可以使用Vec ::new()函数来创建向量。让我们来看看:

复制代码

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

例如:

复制代码

let v = vec![10,20,30,40,50];

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

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(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'变量之前使用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("learnfk"))];
     for i in v
    {
	   println!("{:?}",i);
     }
}