Rust - 数组(Array)

数组是值的同类集合，简而言之，数组是相同数据类型的值的集合。

声明数组

使用下面给出的语法在Rust中声明和初始化一个数组。

//语法1
let variable_name=[value1,value2,value3];

//语法2
let variable_name:[dataType;size]=[value1,value2,value3];

//语法3
let variable_name:[dataType;size]=[default_value_for_elements,size];

在第一种语法中，数组的类型是在初始化期间从数组的第一个元素的数据类型推断出来的。

简单数组

下面的示例显式指定数组的大小和数据类型，println!()函数的 {:?}语法用于打印数组中的所有值，len()函数用于计算数组的大小。

链接：https://www.learnfk.comhttps://www.learnfk.com/rust/rust-array.html

来源：LearnFk无涯教程网

fn main(){
   let arr:[i32;4]=[10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

array is [10, 20, 30, 40]
array size is :4

不指定数据类型

以下程序声明了一个由4个元素组成的数组，在变量声明期间未明确指定数据类型，在这种情况下，数组将为整数类型， len()函数用于计算数组的大小。

fn main(){
   let arr=[10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

array is [10, 20, 30, 40]
array size is :4

默认值

下面的示例创建一个数组，并使用默认值 -1 初始化其所有元素。

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

array is [-1, -1, -1, -1]
array size is :4

for循环数组

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

无涯教程网

fn main(){
   let arr:[i32;4]=[10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for index in 0..4 {
      println!("index is: {} & value is : {}",index,arr[index]);
   }
}

array is [10, 20, 30, 40]
array size is :4
index is: 0 & value is : 10
index is: 1 & value is : 20
index is: 2 & value is : 30
index is: 3 & value is : 40

iter()函数

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

fn main(){

let arr:[i32;4]=[10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for val in arr.iter(){
      println!("value is :{}",val);
   }
}

array is [10, 20, 30, 40]
array size is :4
value is :10
value is :20
value is :30
value is :40

可变数组

关键字 mut 可用于声明可变数组，下面的示例声明一个可变数组，并修改第二个数组元素的值。

fn main(){
   let mut arr:[i32;4]=[10,20,30,40];
   arr[1]=0;
   println!("{:?}",arr);
}

[10, 0, 30, 40]

数组作为参数传递

数组可以按值或对函数的引用进行传递。

按值传递

fn main() {
   let arr=[10,20,30];
   update(arr);

   print!("Inside main {:?}",arr);
}
fn update(mut arr:[i32;3]){
   for i in 0..3 {
      arr[i]=0;
   }
   println!("Inside update {:?}",arr);
}

Inside update [0, 0, 0]
Inside main [10, 20, 30]

引用传递

fn main() {
   let mut arr=[10,20,30];
   update(&mut arr);
   print!("Inside main {:?}",arr);
}
fn update(arr:&mut [i32;3]){
   for i in 0..3 {
      arr[i]=0;
   }
   println!("Inside update {:?}",arr);
}

Inside update [0, 0, 0]
Inside main [0, 0, 0]

数组常量声明

让我们考虑下面给出的示例，以了解数组声明和常量。

fn main() {
   let N: usize=20;
   let arr=[0; N]; //错误：非常量与常量一起使用
   print!("{}",arr[10])
}

编译器将导致异常，这是因为必须在编译时知道数组的长度，此处，变量" N"的值将在运行时确定，换句话说，变量不能用于定义数组的大小。

但是，以下程序有效-

fn main() {
   const N: usize=20; 
   //pointer sized
   let arr=[0; N];

   print!("{}",arr[10])
}

带有const关键字前缀的标识符的值在编译时定义，并且在运行时无法更改， usize是指针大小的，因此实际大小取决于要为其编译程序的体系结构