【Rust 基础入门】(08) | 元组、结构体、枚举

元组（Tuple）

元组是一种复合类型，它将多个不同类型的值组合在一起，并且长度和顺序都是固定的。它们通过圆括号 ( ) 定义，元素之间用逗号 , 分隔。

想象你有一个旅行背包，里面装着不同种类的物品，比如护照（字符串）、现金（整数）、指南针（浮点数）。无论里面的物品是什么类型，它们都属于同一个背包（元组），并且位置固定。

定义元组

// 创建一个包含不同类型元素的元组
let info: (i32, bool, f64, &str) = (42, true, 3.14, "Rust");

// 元组可以嵌套
let nested_tuple: (u8, (char, &str)) = (1, ('A', "嵌套"));

访问元组元素

fn main() {
    let person: (&str, i32, f64) = ("Alice", 30, 1.65);

    // 解构方式获取元组元素
    let (name, age, height) = person;
    println!("{} is {} years old and {}m tall.", name, age, height);

    // 使用索引访问元组元素
    println!("Name: {}, Age: {}, Height: {}", person.0, person.1, person.2);
}

作为函数返回值

fn square_and_cube(n: i32) -> (i32, i32) {
    (n * n, n * n * n)
}

fn main() {
    let (square, cube) = square_and_cube(3);
    println!("Square: {}, Cube: {}", square, cube);
}

结构体（Struct）

结构体是一种自定义数据类型，可以组织多个相关的字段，使代码更清晰易读。可以将结构体看作是人物档案，每个字段代表一个特定信息，比如姓名、年龄、职业等。

定义结构体

struct Book {
    title: String,
    author: String,
    pages: u32,
    is_hardcover: bool,
}

结构体的实例化

fn main() {
    let rust_book = Book {
        title: String::from("The Rust Programming Language"),
        author: String::from("Steve Klabnik and Carol Nichols"),
        pages: 552,
        is_hardcover: true,
    };

    println!("Book: {} by {}", rust_book.title, rust_book.author);
}

结构体更新语法

fn main() {
    let book1 = Book {
        title: String::from("Rust Basics"),
        author: String::from("John Doe"),
        pages: 320,
        is_hardcover: false,
    };

    // 通过已有结构体创建新实例
    let book2 = Book {
        title: String::from("Advanced Rust"),
        ..book1
    };

    println!("{} - {} pages", book2.title, book2.pages);
}

元组结构体（Tuple Struct）

如果你不需要字段名称，但仍然希望使用结构体的特性，可以使用元组结构体。

struct Coordinates(i32, i32, i32);

fn main() {
    let origin = Coordinates(0, 0, 0);
    println!("Origin is at ({}, {}, {})", origin.0, origin.1, origin.2);
}

枚举（Enum）

枚举是一种用户自定义的数据类型，它允许一个类型有多个不同的可能值，每个值称为一个变体（variant）。

想象你正在点一杯咖啡，你可以选择不同的大小（小、中、大），或者不同的口味（黑咖啡、拿铁、摩卡）。这些选项可以用枚举来表示。

定义枚举

enum CoffeeSize {
    Small,
    Medium,
    Large,
}

使用枚举

fn main() {
    let my_coffee = CoffeeSize::Medium;
    match my_coffee {
        CoffeeSize::Small => println!("You chose a small coffee."),
        CoffeeSize::Medium => println!("You chose a medium coffee."),
        CoffeeSize::Large => println!("You chose a large coffee."),
    }
}

带数据的枚举

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

fn main() {
    let msg1 = Message::Text(String::from("Hello, Rust!"));
    let msg2 = Message::Move { x: 10, y: 20 };
    let msg3 = Message::ChangeColor(255, 0, 0);
}

Option 枚举

Rust 没有 null，取而代之的是 Option<T> 枚举，用于表示可能为空的值。它的定义如下：

// 它有两个枚举值，Some(T): 包含一个具体的值 T，以及None: 表示没有值。
enum Option<T> {
    None,
    Some(T),
}

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Some(result) => println!("Result: {}", result),
        None => println!("Cannot divide by zero!"),
    }
}