Rust 定义结构体

在本章中，我们将详细探讨如何在 Rust 中定义和使用结构体。结构体是一种自定义数据类型，允许你将多个不同类型的值组合在一起，形成一个复合的数据类型。这种灵活性使得结构体成为处理复杂数据的理想选择。

结构体的基本概念

在 Rust 中，结构体是通过 struct 关键字来定义的。结构体可以包含多种类型的字段，这些字段可以在结构体实例化时进行初始化。

定义结构体

让我们从一个简单的例子开始。假设我们要创建一个表示二维坐标点的结构体：

struct Point {
    x: f64,
    y: f64,
}

在这个例子中，我们定义了一个名为 Point 的结构体，它有两个字段：x 和 y，它们都是浮点数类型。

实例化结构体

一旦定义了结构体，我们就可以创建它的实例。可以通过命名字段的方式或者位置字段的方式来实例化结构体：

命名字段方式

let origin = Point { x: 0.0, y: 0.0 };

位置字段方式

let origin = Point { x: 0.0, ..Default::default() };

这里我们使用了 Rust 的 Default trait 来为未指定的字段提供默认值。

结构体的方法

除了简单的字段外，结构体还可以拥有方法。方法是与特定类型的实例相关的函数。例如，我们可以为 Point 添加一个计算距离的方法：

impl Point {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

let p = Point { x: 3.0, y: 4.0 };
println!("Distance from origin: {}", p.distance_from_origin());

在这个例子中，我们定义了一个 distance_from_origin 方法，该方法接受一个 &self 参数，表示调用方法的实例。

结构体的生命周期标注

当结构体中的字段引用其他变量时，需要考虑生命周期问题。例如，如果一个结构体包含对字符串的引用，我们需要明确地标注这些引用的生命周期：

// www.javascriptcn.com code example
struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'.");
    let i = ImportantExcerpt {
        part: first_sentence,
    };

    println!("{}", i.part);
}

在这个例子中，ImportantExcerpt 结构体包含一个对字符串的引用，并且使用了生命周期标注 'a 来确保引用的有效性。

结构体的继承和组合

虽然 Rust 不支持传统的面向对象编程中的继承概念，但你可以通过组合的方式来实现类似的功能。组合是指在一个结构体中包含另一个结构体作为其字段，从而达到复用代码的目的。

例如，我们可以定义两个结构体：一个表示形状，另一个表示颜色：

// www.javascriptcn.com code example
struct Shape {
    width: u32,
    height: u32,
}

struct ColoredShape {
    shape: Shape,
    color: String,
}

fn main() {
    let rectangle = Shape { width: 100, height: 50 };
    let red_rectangle = ColoredShape {
        shape: rectangle,
        color: String::from("red"),
    };

    println!(
        "A {} rectangle with width {} and height {}",
        red_rectangle.color, red_rectangle.shape.width, red_rectangle.shape.height
    );
}

在这个例子中，ColoredShape 包含了一个 Shape 实例，这样我们就可以将颜色信息附加到任何形状上。

结构体和模式匹配

Rust 强大的模式匹配功能也可以应用于结构体，这使得根据不同的结构体实例执行不同的操作变得非常简单。

// www.javascriptcn.com code example
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Exiting program."),
        Message::Move { x, y } => println!("Moving to ({}, {}).", x, y),
        Message::Write(text) => println!("Writing: {}", text),
        Message::ChangeColor(r, g, b) => println!("Changing color to RGB({}, {}, {}).", r, g, b),
    }
}

fn main() {
    process_message(Message::Move { x: 10, y: 20 });
}

在这个例子中，我们定义了一个枚举 Message，其中包含了几个不同的结构体变体。在 process_message 函数中，我们使用 match 语句根据不同的变体来执行相应的操作。

结构体和并发

Rust 提供了强大的并发支持，包括原子类型、消息传递、共享内存等。对于结构体来说，我们可以利用这些工具来创建线程安全的数据结构。

例如，我们可以使用 Arc 和 Mutex 来创建一个可以在线程间共享的结构体实例：

// www.javascriptcn.com code example
use std::sync::{Arc, Mutex};
use std::thread;

struct SharedData {
    count: i32,
}

fn main() {
    let data = Arc::new(Mutex::new(SharedData { count: 0 }));

    for _ in 0..10 {
        let data = Arc::clone(&data);

        thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data.count += 1;
            println!("Count is now {}", data.count);
        });
    }

    // 等待所有线程完成
    thread::sleep(std::time::Duration::from_secs(1));
}

在这个例子中，我们定义了一个 SharedData 结构体，并使用 Arc<Mutex<SharedData>> 来在线程间安全地共享数据。每个线程都会增加 count 字段的值，并打印当前计数值。

结构体和序列化/反序列化

Rust 提供了多种库来帮助处理序列化和反序列化，比如 serde 库。通过使用这些库，我们可以很容易地将结构体转换为 JSON 或其他格式，以及从这些格式反序列化回结构体。

首先，你需要在 Cargo.toml 文件中添加 serde 和 serde_derive 依赖：

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

然后，你可以定义一个可以被序列化的结构体：

// www.javascriptcn.com code example
#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u8,
    email: String,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 27,
        email: String::from("alice@example.com"),
    };

    // 序列化
    let serialized = serde_json::to_string(&person).unwrap();
    println!("Serialized Person: {}", serialized);

    // 反序列化
    let deserialized: Person = serde_json::from_str(&serialized).unwrap();
    println!("Deserialized Person: {:?}", deserialized);
}

在这个例子中，我们定义了一个 Person 结构体，并使用 #[derive(Serialize, Deserialize)] 注解来自动实现序列化和反序列化功能。接着，我们演示了如何将结构体实例序列化为 JSON 字符串，并将其反序列化回结构体实例。

通过以上内容，你应该已经对如何在 Rust 中定义和使用结构体有了一个全面的理解。结构体是 Rust 编程中的一个重要组成部分，掌握好结构体的使用技巧，可以帮助你更好地组织和管理程序中的数据。