皇上,还记得我吗?我就是1999年那个Linux伊甸园啊-----24小时滚动更新开源资讯,全年无休!

Rust 基础系列 #4: Rust 中的数组和元组

Rust 基础系列 #4: Rust 中的数组和元组

在 Rust 系列的第四篇中,学习复合数据类型、数组和元组。

在上一篇文章中,你学习到了 Rust 中的 标量数据类型。它们是整型、浮点数、字符和布尔值。

在本文中,我们将会看看 Rust 编程语言中的复合数据类型。

Rust 中的复合数据类型是什么?

复合数据类型可以在一个变量中存储多个值。这些值可以是相同的标量数据类型,也可以是不同的标量数据类型。

Rust 编程语言中有两种这样的数据类型:

  • 数组Array:存储相同类型的多个值。
  • 元组Tuple:存储多个值,可以是相同的类型,也可以是不同的类型。

让我们了解一下它们吧!

Rust 中的数组

Rust 编程语言中的数组具有以下特性:

  • 每一个元素都必须是相同的类型
  • 数组有一个固定的长度
  • 数组存储在堆栈中,即其中存储的数据可以被 迅速 访问

创建数组的语法如下:

  1. // 无类型声明
  2. let variable_name = [element1, element2, ..., elementn];
  3. // 有类型声明
  4. let variable_name: [data_type; array_length] = [element1, element2, ..., elementn];

数组中的元素是在方括号中声明的。要访问数组的元素,需要在方括号中指定要访问的索引。

来让我们看一个例子来更好地理解这个。

  1. fn main() {
  2. // 无类型声明
  3. let greeting = ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];
  4. // 有类型声明
  5. let pi: [i32; 10] = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
  6. for character in greeting {
  7. print!("{}", character);
  8. }
  9. println!("\nPi: 3.1{}{}{}{}", pi[0], pi[1], pi[2], pi[3]);
  10. }

这里,我定义了一个字符数组和另一个存储 i32 类型的值的数组。greeting 数组以单独字符的形式存储了字符串 "Hello world!" 的字符。pi 数组以单独数字的形式存储了圆周率小数点后的前 10 位数字。

然后,我使用 for 循环打印了 greeting 数组的每个字符。(我很快就会讲到循环。)然后,我打印了 pi 数组的前 4 个值。

  1. Hello world!
  2. Pi: 3.11415

如果你想创建一个数组,其中每个元素都是 y,并且出现 x 次,你可以使用以下快捷方式在 Rust 中实现:

  1. let variable_name = [y; x];

来看一个演示……

  1. fn main() {
  2. let a = [10; 5];
  3. for i in a {
  4. print!("{i} ");
  5. }
  6. println!("");
  7. }

我创建了一个变量 a,它的长度为 5。数组中的每个元素都是 ’10’。我通过使用 for 循环打印数组的每个元素来验证这一点。

它的输出如下:

  1. 10 10 10 10 10

作为练习,尝试创建一个长度为 x 的数组,然后尝试访问数组的第 x+1 个元素。看看会发生什么。

Rust 中的元组

Rust 中的元组具有以下特性:

  • 就像数组一样,元组的长度是固定的
  • 元素可以是相同的/不同的标量数据类型
  • 元组存储在堆栈中,所以访问速度更快

创建元组的语法如下:

  1. // 无类型声明
  2. let variable_name = (element1, element2, ..., element3);
  3. // 有类型声明
  4. let variable_name: (data_type, ..., data_type) = (element1, element2, ..., element3);

元组的元素写在圆括号中。要访问元素,使用点运算符,后跟该元素的索引。

  1. fn main() {
  2. let a = (38, 923.329, true);
  3. let b: (char, i32, f64, bool) = ('r', 43, 3.14, false);
  4. println!("a.0: {}, a.1: {}, a.2: {}", a.0, a.1, a.2);
  5. println!("b.0: {}, b.1: {}, b.2: {}, b.3: {}", b.0, b.1, b.2, b.3);
  6. // 元组解构
  7. let pixel = (50, 0, 200);
  8. let (red, green, blue) = pixel;
  9. println!("red: {}, green: {}, blue: {}", red, green, blue);
  10. }

在上面的代码中,我在第 2 行和第 3 行声明了两个元组。它们只包含我当时想到的随机值。但是仔细看,两个元组中每个元素的数据类型都不同。然后,在第 5 行和第 6 行,我打印了两个元组的每个元素。

在第 9 行,我声明了一个名为 pixel 的元组,它有 3 个元素。每个元素都是组成像素的颜色红色、绿色和蓝色的亮度值。这个范围是从 0 到 255。所以,理想情况下,我会声明类型为 (u8, u8, u8),但是在学习代码时不需要这样优化 ; )

然后,在第 10 行,我“解构”了 pixel 元组的每个值,并将其存储在单独的变量 redgreen 和 blue 中。然后,我打印了 redgreen 和 blue 变量的值,而不是 pixel 元组的值。

让我们看看输出……

  1. a.0: 38, a.1: 923.329, a.2: true
  2. b.0: r, b.1: 43, b.2: 3.14, b.3: false
  3. red: 50, green: 0, blue: 200

看起来不错 : )

额外内容:切片

准确的来说,切片Slice 不是 Rust 中的复合数据类型。相反,切片是现有复合数据类型的 “切片”。

一个切片由三个元素组成:

  • 一个初始索引
  • 切片运算符(.. 或 ..=
  • 一个结束索引

接下来是数组切片的一个示例:

  1. fn main() {
  2. let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  3. let my_slice = &my_array[0..4];
  4. for element in my_slice {
  5. println!("{element}");
  6. }
  7. }

就像 C 和 C++ 一样,& 用于存储变量的引用(而不是原始指针)。所以 &my_array 意味着对变量 my_array 的引用。

然后,来看看切片。切片由 [0..4] 表示。这里,0 是切片开始的索引。而 4 是切片结束的索引。这里的 4 是一个非包含索引。

这是程序输出,以更好地理解正在发生的事情:

  1. 0
  2. 1
  3. 2
  4. 3

如果你想要一个 包含 范围,你可以使用 ..= 作为包含范围的切片运算符。

  1. fn main() {
  2. let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  3. let my_slice = &my_array[0..=4];
  4. for element in my_slice {
  5. println!("{element}");
  6. }
  7. }

现在,这个范围是从第 0 个元素到第 4 个元素,下面是输出来证明这一点:

  1. 0
  2. 1
  3. 2
  4. 3
  5. 4

总结

本文讲到了 Rust 编程语言中的复合数据类型。你学习了如何声明和访问存储在数组和元组类型中的值。此外,你还了解了切片“类型”,以及如何解构元组。

在下一章中,你将学习如何在 Rust 程序中使用函数。敬请关注。

(题图:MJ/22a0d143-2216-439f-8e1d-abd94cdfdbd0)


via: https://itsfoss.com/rust-arrays-tuples/

作者:Pratham Patel 选题:lkxed 译者:Cubik65536 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

转自 软件开发|Rust 基础系列 #4: Rust 中的数组和元组 (linux.cn)