跳到主要内容

Rust 元组

提示
  1. 元组的定义和用途：Rust 元组可以存储不同数据类型的值，具有固定大小，一旦创建，其大小不可改变。
  2. 创建和访问元组：元组可以带或不带数据类型声明创建，访问元组的元素通过索引（如 tuple.0），索引从 0 开始。
  3. 元组的可变性和解构：使用 mut 关键字创建可变元组，允许修改元素值，但不改变元素类型。元组解构允许将元组的值分配给单独的变量。

Rust 中的元组允许我们存储不同数据类型的值。例如，

let tuple = ('Hello', 5, 3.14);

在这里，我们使用小括号 ( ) 创建了一个元组，并且它能够同时存储一个字符串值 Hello、一个整数值 5 和一个浮点数值 3.14。

注意：在 Rust 中，元组具有固定大小，创建后无法增长或缩小。

在 Rust 中创建元组​

在 Rust 中，我们可以用两种不同的方式创建元组：

  1. 带数据类型的元组
  2. 不带数据类型的元组

让我们详细了解它们各自的特点。

带数据类型的 Rust 元组​

在创建元组时，我们可以声明它存储的数据类型。例如，

// 创建带数据类型的元组
let student_info: (&str, u8, f32) = ("Ricky", 21, 3.56);

这里，

  • let student_info: (&str, u8, f32) - 指定了变量名称和元组元素的数据类型
  • ("Ricky", 21, 3.56) - 指定了元组的元素

示例：带数据类型的元组​

fn main() {
    // 初始化带数据类型的元组
    let tuple: (&str, f32, u8) = ("Rust", 3.14, 100);

    println!("元组内容 = {:?}", tuple);
}

输出

元组内容 = ("Rust", 3.14, 100)

注意： 我们在 println! 函数中使用 :? 来打印整个元组。

不带数据类型的 Rust 元组​

我们可以在不声明数据类型的情况下创建元组。Rust 编译器可以自动检测并设置数据类型。例如，

// 创建不带数据类型的元组
let student_info = ("Ricky", 21, 3.56);

这里，

  • let student_info - 指定了元组的变量名
  • ("Ricky", 21, 3.56) - 指定了元组的元素

示例：不带数据类型的元组​

fn main() {
    // 初始化不带数据类型的元组
    let tuple = ("Rust", "fun", 100);

    println!("元组内容 = {:?}", tuple);
}

输出

元组内容 = ("Rust", "fun", 100)

访问元组中的元素​

元组中的每个元素都与唯一的数字序列相关联。这个数字被称为元组索引或简称索引。

假设我们有一个元组，

let random_tuple = ("Hello", 200, 3.14);

random_tuple 的元组索引如下图所示，

Rust 中的元组索引可视化

在 Rust 中，我们可以使用点 . 符号和对应的元组索引来访问单个元组元素。例如，

  • random_tuple.0 - 访问索引 0 处的元素（第一个元素）
  • random_tuple.1 - 访问索引 1 处的元素（第二个元素）
  • random_tuple.2 - 访问索引 2 处的元素（第三个元素）

示例：访问元组元素​

fn main() {
    let random_tuple = ("Hello", 200, 3.14);

    // 访问索引 0 处的元组元素
    println!("索引 0 处的值 = {}", random_tuple.0);

    // 访问索引 1 处的元组元素
    println!("索引 1 处的值 = {}", random_tuple.1);

    // 访问索引 2 处的元组元素


    println!("索引 2 处的值 = {}", random_tuple.2);
}

输出

索引 0 处的值 = Hello
索引 1 处的值 = 200
索引 2 处的值 = 3.14

注意： 元组的索引总是从 0 开始；因此，元组的第一个元素位于位置 0，而不是 1。

可变元组​

在 Rust 中，元组是不可变的，这意味着一旦创建就无法更改其元素。

然而，我们可以通过在变量赋值前使用 mut 关键字来创建一个可变数组。例如，

// 创建一个可变元组
let mut mountains = ("Everest", 8848, "Fishtail", 6993);

现在，我们可以对这个元组进行更改。

让我们看一个例子，

fn main() {
    // 初始化一个可变元组
    let mut mountain_heights = ("Everest", 8848, "Fishtail", 6993);

    println!("原始元组 = {:?}", mountain_heights);

    // 更改可变元组的第 3 和第 4 个元素
    mountain_heights.2 = "Lhotse";
    mountain_heights.3 = 8516;

    println!("更改后的元组 = {:?}", mountain_heights);
}

输出

原始元组 = ("Everest", 8848, "Fishtail", 6993)
更改后的元组 = ("Everest", 8848, "Lhotse", 8516)

这里，我们创建了一个名为 mountain_heights 的可变元组。然后我们更改了它的第 3 和第 4 个元素，即第 2 和第 3 个元组索引。

mountain_heights.2 = "Lhotse";
mountain_heights.3 = 8516;

注意： 只能将元组的元素更改为与创建时相同的类型。元组创建后不允许更改数据类型。

解构元组​

我们可以在 Rust 中将元组拆解为较小的变量，这被称为 解构。

假设我们有一个元组，

let tuple = ("John Doe", 18, 178);

现在，我们可以使用以下方式进行解构，

let (name, age, height) = tuple;

现在，我们可以直接访问 name、age 和 height 变量，而无需使用元组索引。

  • 使用 name 代替 tuple.0
  • 使用 age 代替 tuple.1
  • 使用 height 代替 tuple.2

在解构元组时，你可以随意命名变量。

注意：解构元组也被称为 元组解包。

示例：解构元组​

fn main() {
    let mixture = ("Hello, World!", 16, 2.71828);

    // 解构元组
    let (message, number, float) = mixture;

    println!("message = {}", message);
    println!("number = {}", number);
    println!("float = {}", float);
}

输出

message = Hello, World!
number = 16
float = 2.71828

在这里，我们将元组 mixture 解构为变量 message、number 和 float。

let (message, number, float) = mixture;

最后，我们将这些变量打印到屏幕上。

最后于 更新