Rust – 数组

Rust 编程中的 AN 数组是一个固定大小的元素集合，用 [T; N] 其中 T 是元素类型，N 是数组的编译时常量大小。

我们可以通过两种不同的方式创建数组：

1. 只是一个包含每个元素 [a, b, c] 的列表。
2. 重复表达式 [N, X]。这将创建一个包含 X 的 N 个副本的数组。

[X,0] 它是允许的，但可能会导致一些繁忙的问题，因此如果您使用这种类型的表达式，请注意副作用。如果其类型允许，则 0-32 的数组大小实现默认特征。 Trait 实现最多有 32 种大小。数组本身不可迭代。

句法：

ArrayType : [ Type ; Expression ]

一个数组写成：

let array: [i32; 3] = [4, 5, 6];

数组的特点：

数组的特性如下：

• 阵列中的内存块按顺序排列。
• 一旦创建了数组，就无法调整其大小，这意味着该数组是静态的。
• 数组元素由内存块表示
• 为了标识数组元素，我们使用称为下标的唯一整数。
• 将值放入数组元素称为数组初始化。
• 数组元素中的值可以更新或修改，但不能删除。

声明和初始化数组：

下面给出的附加税可用于在 Rust 中声明和初始化数组：

Syntax1: let variable_name = [value_1,value_2,value_3];

Syntax2: let variable_name:[dataType;array_size] = [value_1,value_2,value_3];

Syntax3: let variable_name:[dataType;array_size] = [default_value_for_elements,array_size];

数据类型的值是从数组的第一个变量的数据类型中获取的。

打印简单数组的元素

要打印数组中的所有值，请使用println!()函数的 {:?} 语法。要计算数组的大小，我们可以使用len()函数。

示例 1：打印数组中的元素

Rust

#![allow(unused)]
fn main() {
let mut array: [i32; 5] = [0; 5];
  
array[1] = 1;
array[2] = 2;
array[3] = 3;
array[4] = 4;
assert_eq!([1, 2 , 3 ,4], &array[1..]);
  
// This loop prints: 0 1 2 3 4
for x in &array {
   print!("{} ", x);
}
}

输出：

0 1 2 3 4

示例 2：打印数组中的元素

锈

fn main(){
  let arr:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
}

输出：

array is [1, 2, 3, 4, 5]
array size is :5

使用没有数据类型的数组：

下面的程序声明了一个包含 5 个元素的数组。这里我们没有在变量声明期间明确定义数据类型。因此，数组将是整数类型。要计算数组的大小，我们可以使用 len()函数。

锈

fn main(){
  let arr = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
}

输出：

array is [1, 2, 3, 4, 5]
array size is :5

数组默认值：

让我们创建一个数组并使用默认值 0 初始化所有值。

锈

fn main() {
  let gfg_array:[i32;5] = [0;5];
  println!("array is {:?}",gfg_array);
  println!("array size is :{}",gfg_array.len());
}

输出：

array is [0, 0, 0, 0, 0]
array size is :5

在 Array 上使用循环：

以下示例遍历数组并打印索引及其对应的值。循环检索从索引 0 到 4（最后一个数组元素的索引）的值。

在此示例中，数组由循环迭代并打印索引和值。循环检索从 0 到 5 的值

锈

fn main(){
  let gfg_array:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",gfg_array);
  println!("array size is :{}",gfg_array.len());
  
  for index in 0..5 {
     println!("index is: {} & value is : {}",index,gfg_array[index]);
  }
}

输出：

array is [1, 2, 3, 4, 5]
array size is :5
index is: 0 & value is : 1
index is: 1 & value is : 2
index is: 2 & value is : 3
index is: 3 & value is : 4
index is: 4 & value is : 5

在数组上使用 iter()函数：

iter()函数获取数组中所有元素的值。

锈

fn main(){
  
let arr:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
  
  for val in arr.iter(){
     println!("value is :{}",val);
  }
}

输出：

array is [1, 2, 3, 4, 5]
array size is :5
index is: 0 & value is : 1
index is: 1 & value is : 2
index is: 2 & value is : 3
index is: 3 & value is : 4
index is: 4 & value is : 5

可变数组的概念：

要声明可变数组，我们使用“ mut ”键。可变数组是那些元素可以改变的数组。请参阅下面的示例以更好地理解。

锈

fn main(){
  let mut arr:[i32;5] = [1,2,3,4,5];
  arr[1] = 0;
  println!("{:?}",arr);
}

输出：

[1, 0, 3, 4, 5]

我们已经更新了索引号为“1”的数组的值并打印了该值。

将数组作为参数传递给函数：

我们可以通过按值调用或通过引用函数调用将数组作为参数传递。

示例 1：按值传递

锈

fn main() {
  let gfg_array = [1,2,3,4];
  change_array(gfg_array);
  
  print!("Original array {:?}",gfg_array);
}
fn change_array(mut gfg_array:[i32;4]){
  for i in 0..4 {
     gfg_array[i] = 0;
  }
  println!("Changed array {:?}",gfg_array);
}

输出：

Changed array [0, 0, 0, 0]
Original array [1, 2, 3, 4]

示例 2：通过引用传递

锈

#![allow(unused)]
  
fn main() {
  let mut gfg_array = [1,2,3,4,5];
  change_array(&mut gfg_array);
  print!("Original array {:?}",gfg_array);
}
fn change_array(gfg_array:&mut [i32;5]){
  for i in 0..5 {
     gfg_array[i] = 0;
  }
  println!("Changed array {:?}",gfg_array);
}

输出：

Changed array [0, 0, 0, 0, 0]
Original array [0, 0, 0, 0, 0]