Rust 复合类型

结构体 (Structs)

在 Rust 中，结构体是一种复合类型，用于定义具有多个字段的数据结构。你可以将结构体视为一种自定义的数据类型，它允许你将相关的数据捆绑在一起。

定义结构体

使用 struct 关键字来定义一个结构体。下面是一个简单的例子：

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

在这个例子中，我们定义了一个名为 User 的结构体，它包含四个字段：username、email、sign_in_count 和 active。

实例化结构体

要创建结构体的实例，可以使用结构体名后跟一组大括号，其中包含各个字段的值。例如：

let user1 = User {
    username: String::from("someone82"),
    email: String::from("someone@example.com"),
    active: true,
    sign_in_count: 1,
};

如果你想要省略某些字段，那么你需要指定所有字段的名称。例如：

let user2 = User {
    email: String::from("another@example.com"),
    username: String::from("anotheruser"),
    ..user1
};

在这里，我们通过使用点和点符号 ..user1 来表示我们想要使用 user1 的其余字段。

元组结构体

元组结构体是另一种类型的结构体，它类似于元组，但每个元组结构体都有一个名称，这使得它成为一个不同的类型。元组结构体没有命名字段，只有类型。

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);

单位结构体

单位结构体是一种特殊的结构体，它没有任何字段。它们可以用于实现 trait 或者在泛型中作为占位符使用。

struct Nil;

struct Pair(i32, f32);

let pair = Pair(1, 0.1);
let nil = Nil;

枚举 (Enums)

枚举是一种复合类型，允许你定义一个有限的变量集合，每个变量都代表某种特定的状态或条件。在 Rust 中，枚举允许你创建更清晰和更具表现力的代码。

定义枚举

使用 enum 关键字来定义一个枚举。下面是一个简单的例子：

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

在这个例子中，我们定义了一个名为 Message 的枚举，它包含四种可能的变体：Quit、Move、Write 和 ChangeColor。Move 变体有一个带有标签的匿名元组结构体，而 Write 和 ChangeColor 则是简单的元组。

使用枚举

你可以像处理其他类型一样处理枚举，例如，使用匹配表达式来根据枚举的不同变体执行不同的操作。

// www.javascriptcn.com code example
fn process_message(msg: Message) {
    match msg {
        Message::Quit => {
            println!("Quit");
        }
        Message::Move { x, y } => {
            println!("Move to x: {}, y: {}", x, y);
        }
        Message::Write(text) => {
            println!("Write: {}", text);
        }
        Message::ChangeColor(r, g, b) => {
            println!("Change color to r: {}, g: {}, b: {}", r, g, b);
        }
    }
}

let quit_msg = Message::Quit;
let move_msg = Message::Move { x: 10, y: 20 };
let write_msg = Message::Write(String::from("Hello World"));
let color_msg = Message::ChangeColor(255, 0, 0);

process_message(quit_msg);
process_message(move_msg);
process_message(write_msg);
process_message(color_msg);

元组 (Tuples)

元组是 Rust 中的一种复合类型，它允许你将不同类型的数据组合在一起。元组中的元素可以通过索引访问，索引从零开始。

定义元组

定义元组非常简单，只需列出元素类型并用逗号分隔即可：

let tup: (i32, f64, u8) = (500, 6.4, 1);

访问元组元素

可以使用点运算符和索引来访问元组中的元素：

let tup = (500, 6.4, 1);
let five_hundred = tup.0;
let six_point_four = tup.1;
let one = tup.2;

解构元组

你也可以在赋值时解构元组，从而将元组中的元素分配给单独的变量：

let tup = (500, 6.4, 1);

let (a, b, c) = tup;

println!("The value of a is: {}", a);
println!("The value of b is: {}", b);
println!("The value of c is: {}", c);

数组 (Arrays)

数组是一种固定长度的序列，这意味着一旦创建了数组，其长度就不可改变。数组中的所有元素必须是相同类型。

定义数组

定义数组的方式是提供类型注释，后跟方括号和长度：

let a: [i32; 5] = [1, 2, 3, 4, 5];

或者你可以通过重复单个值来初始化数组：

let a = [3; 5]; // 等同于 [3, 3, 3, 3, 3]

访问数组元素

你可以使用索引来访问数组中的元素：

let a = [1, 2, 3, 4, 5];

let first = a[0];
let second = a[1];

请注意，数组的索引是从零开始的，且访问数组的索引超出范围会导致运行时错误。

向量 (Vectors)

向量是动态数组，它们可以在运行时增长或收缩。与数组不同，向量中的元素不必是相同的类型。

创建向量

使用 Vec 类型来创建向量。你可以使用 vec! 宏来初始化一个向量：

let v: Vec<i32> = Vec::new();

let v = vec![1, 2, 3];

添加元素

使用 push 方法可以向向量添加新的元素：

let mut v = Vec::new();

v.push(5);
v.push(6);
v.push(7);
v.push(8);

访问元素

要访问向量中的元素，可以使用 get 方法或直接通过索引：

// www.javascriptcn.com code example
let v = vec![1, 2, 3, 4, 5];

let third: &i32 = &v[2];
println!("The third element is {}", third);

match v.get(2) {
    Some(third) => println!("The third element is {}", third),
    None => println!("There is no third element."),
}

请注意，使用索引访问元素时，如果索引超出范围会引发 panic，而使用 get 方法则返回一个可选值，不会导致程序崩溃。

以上便是 Rust 中几种常见的复合类型介绍。这些类型提供了多种方式来组织和操作数据，并且每种类型都有其独特的用途和优势。