Rust 元组

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

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

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

注意：在 Rust 中，元组的大小是固定的，一旦创建就无法增长或缩小。

在 Rust 中创建元组

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

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

让我们详细了解其中的每一个。

带数据类型的 Rust 元组

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

// create a tuple with data type
let student_info: (&str, u8, f32) = ("Ricky", 21, 3.56);

这里，

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

示例：带数据类型的元组

fn main() {
    // initialization of tuple with data type
    let tuple: (&str, f32, u8) = ("Rust", 3.14, 100);
    
    println!("Tuple contents = {:?}", tuple);
}

输出

Tuple contents = ("Rust", 3.14, 100)

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

Rust 中不带数据类型的元组

我们可以创建不指定数据类型的元组。Rust 编译器可以自动检测并设置数据类型。例如：

// create a tuple without data type
let student_info = ("Ricky", 21, 3.56);

这里，

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

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

fn main() {
    // initialization of tuple without data type
    let tuple = ("Rust", "fun", 100);

    println!("Tuple contents = {:?}", tuple);
}

输出

Tuple contents = ("Rust", "fun", 100)

访问元组中的元素

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

假设我们有一个元组，

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

`random_tuple` 的元组索引如下所示：

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

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

示例：访问元组元素

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

    // accessing tuple element at index 0
    println!("Value at Index 0 = {}", random_tuple.0);
    
    // accessing tuple element at index 1
    println!("Value at Index 1 = {}", random_tuple.1);
    
    // accessing tuple element at index 2
    println!("Value at Index 2 = {}", random_tuple.2);
}

输出

Value at Index 0 = Hello
Value at Index 1 = 200
Value at Index 2 = 3.14

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

可变元组

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

但是，我们可以通过在变量名前加上 `mut` 关键字来创建一个可变元组。例如：

// create a mutable tuple 
let mut mountains = ("Everest", 8848, "Fishtail", 6993);

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

让我们看一个例子：

fn main() {
    // initialize a mutable tuple
    let mut mountain_heights = ("Everest", 8848, "Fishtail", 6993);
    
    println!("Original tuple = {:?}", mountain_heights);
    
    // change 3rd and 4th element of a mutable tuple
    mountain_heights.2 = "Lhotse";
    mountain_heights.3 = 8516;
    
    println!("Changed tuple = {:?}", mountain_heights);
}

输出

Original tuple = ("Everest", 8848, "Fishtail", 6993)
Changed tuple = ("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);
    
    // destructuring a tuple
    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;

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