上一节:
下一节:

  Rust - 数组

  • 简述

    在本章中，我们将了解数组以及与之相关的各种功能。在我们学习数组之前，让我们看看数组与变量的不同之处。
    变量有以下限制 -
    • 变量本质上是标量。换句话说，变量声明一次只能包含一个值。这意味着在程序中存储 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];
    在第一种语法中，数组的类型是在初始化期间从数组的第一个元素的数据类型推断出来的。

    Illustration：简单数组

    以下示例明确指定数组的大小和数据类型。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

    Illustration：没有数据类型的数组

    以下程序声明了一个包含 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

    Illustration：默认值

    以下示例创建一个数组并使用默认值-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

    Illustration：带有 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

    Illustration：使用 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

    Illustration：可变数组

    的MUT关键字可用于声明一个可变数组。下面的示例声明一个可变数组并修改第二个数组元素的值。 
    
fn main(){
   let mut arr:[i32;4] = [10,20,30,40];
   arr[1] = 0;
   println!("{:?}",arr);
}

    输出

    
[10, 0, 30, 40]

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

    数组可以通过值或通过引用函数来传递。

    Illustration：按值传递

    
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]

    Illustration：通过引用传递

    
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 是指针大小的，因此它的实际大小取决于您编译程序的体系结构。
上一节:
下一节: