Rust 数组

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];

在第一个语法中，数组的类型是根据数组的第一个元素的数据类型在初始化过程中推导出来的。

示例：简单数组

以下示例是显式地指定了数组的大小和数据类型。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是指针大小，因此它的实际大小取决于您为程序编译的体系结构。