📌  相关文章
📜  Rust-数组

📅  最后修改于: 2020-11-02 04:16:36             🧑  作者: Mango

在本章中，我们将学习数组及其相关的各种功能。在学习数组之前，让我们看一下数组与变量的区别。

变量具有以下限制-

  • 变量本质上是标量。换句话说，变量声明一次只能包含一个值。这意味着要在程序中存储n个值，将需要n个变量声明。因此，当需要存储更大的值集合时，使用变量是不可行的。

  • 程序中的变量以随机顺序分配给内存，因此很难按声明的顺序检索/读取值。

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

阵列的功能

数组的功能如下所列-

  • 数组声明分配顺序的内存块。

  • 数组是静态的。这意味着数组一旦初始化就无法调整大小。

  • 每个存储块代表一个数组元素。

  • 数组元素由称为元素的下标/索引的唯一整数标识。

  • 填充数组元素称为数组初始化。

  • 数组元素值可以更新或修改，但不能删除。

声明和初始化数组

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

句法

//Syntax1
let variable_name = [value1,value2,value3];

//Syntax2
let variable_name:[dataType;size] = [value1,value2,value3];

//Syntax3
let variable_name:[dataType;size] = [default_value_for_elements,size];

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

插图：简单数组

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

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]; //Error: non-constant used with constant
   print!("{}",arr[10])
}

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

但是，以下程序有效-

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

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

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