keywords: Rust 结构体, Rust 枚举, Rust 集合类型, Rust 动态数组, Rust 哈希表

description: 本章节将深入探讨 Rust 中的结构体、枚举和集合类型的定义和使用方法，包括动态数组 Vec 和哈希表 HashMap 的操作，帮助读者掌握这些高级特性。

在本章中，我们将探讨 Rust 中几种非常重要的数据结构：结构体、枚举 和 集合类型。理解并熟练使用这些特性将极大提升你的 Rust 编程能力，特别是在构建复杂的数据模型时。

4.1 定义和使用结构体

结构体（Struct）是 Rust 中用来创建复杂数据类型的基本构建块。它允许你将不同类型的数据组合在一起，并为它们命名。

4.1.1 基本定义

让我们从一个简单的结构体定义开始：

  1. // 定义一个名为 User 的结构体
  2. struct User {
  3.     name: String,
  4.     age: u32,
  5.     email: String,
  6. }

在上面的例子中，我们定义了一个 User 结构体，它包含了 name、age 和 email 三个字段。每个字段都有一个类型。

4.1.2 实例化和访问

要创建一个结构体的实例，我们可以这样做：

  1. fn main() {
  2.     // 创建一个 User 结构体实例
  3.     let user1 = User {
  4.         name: String::from("Alice"),
  5.         age: 30,
  6.         email: String::from("alice@example.com"),
  7.     };
  9.     // 访问结构体字段
  10.     println!("Name: {}, Age: {}, Email: {}", user1.name, user1.age, user1.email);
  11. }

4.1.3 结构体方法

你还可以为结构体定义方法：

  1. impl User {
  2.     // 一个实例方法
  3.     fn introduce(&self) {
  4.         println!("Hi, my name is {} and I am {} years old. You can contact me at {}.", self.name, self.age, self.email);
  5.     }
  7.     // 一个关联函数
  8.     fn new(name: String, age: u32, email: String) -> User {
  9.         User { name, age, email }
  10.     }
  11. }
  13. fn main() {
  14.     let user1 = User::new(String::from("Alice"), 30, String::from("alice@example.com"));
  15.     user1.introduce();
  16. }

4.1.4 使用结构体的场景

结构体在组织和管理复杂数据时非常有用，常用于创建配置对象、处理 JSON 数据等场景。

  1. classDiagram
  2. class User {
  3.   +name: String
  4.   +age: u32
  5.   +email: String
  6.   +new(name: String, age: u32, email: String) -> User
  7.   +introduce(&self)
  8. }

4.2 定义和使用枚举

枚举（Enum）允许你定义一个类型，它的值可以是几个不同的变体之一。每个变体可以有不同的数据类型。

4.2.1 枚举定义

我们先来看一个简单的枚举定义：

  1. enum Message {
  2.     Quit,
  3.     Move { x: i32, y: i32 },
  4.     Write(String),
  5.     ChangeColor(i32, i32, i32),
  6. }

4.2.2 使用枚举

你可以这样使用枚举：

  1. fn main() {
  2.     let msg1 = Message::Quit;
  3.     let msg2 = Message::Move { x: 10, y: 20 };
  4.     let msg3 = Message::Write(String::from("Hello"));
  5.     let msg4 = Message::ChangeColor(255, 255, 255);
  7.     match msg4 {
  8.         Message::Quit => println!("Quit"),
  9.         Message::Move { x, y } => println!("Move to x: {}, y: {}", x, y),
  10.         Message::Write(text) => println!("Message: {}", text),
  11.         Message::ChangeColor(r, g, b) => println!("Change color to red: {}, green: {}, blue: {}", r, g, b),
  12.     }
  13. }

4.2.3 使用枚举的场景

枚举在处理状态机、网络协议解析等场景中非常有用。

4.3 动态数组 Vec 和哈希表 HashMap

集合类型在处理动态和不确定数量的数据时非常有用。Rust 提供了强大的集合类型如 Vec 和 HashMap。

4.3.1 动态数组 Vec

Vec 是一个动态数组，它可以根据需要动态扩展和缩小。

  1. fn main() {
  2.     let mut v: Vec<i32> = Vec::new();
  3.     v.push(1);
  4.     v.push(2);
  5.     v.push(3);
  7.     for i in &v {
  8.         println!("{}", i);
  9.     }
  11.     // 通过索引访问
  12.     let third: i32 = v[2];
  13.     println!("The third element is {}", third);
  15.     // 通过 get 方法访问
  16.     match v.get(2) {
  17.         Some(third) => println!("The third element is {}", third),
  18.         None => println!("There is no third element."),
  19.     }
  20. }

4.3.2 哈希表 HashMap

HashMap 是一个键值对集合，适用于需要通过键快速查找值的场景。

  1. use std::collections::HashMap;
  3. fn main() {
  4.     let mut scores = HashMap::new();
  6.     scores.insert(String::from("Blue"), 10);
  7.     scores.insert(String::from("Yellow"), 50);
  9.     let team_name = String::from("Blue");
  10.     let score = scores.get(&team_name);
  12.     match score {
  13.         Some(score) => println!("The score for {} is {}", team_name, score),
  14.         None => println!("No score found for {}", team_name),
  15.     }
  17.     // 遍历 HashMap
  18.     for (key, value) in &scores {
  19.         println!("{}: {}", key, value);
  20.     }
  21. }

4.3.3 使用集合类型的场景

集合类型在处理动态数据、数据聚合和查找操作中非常有用，常用于实现缓存、集合操作、统计计算等场景。

  1. graph LR
  2. A[起点] --> B[动态数组 Vec]
  3. B --> C[添加元素]
  4. C --> D[遍历元素]
  5. A --> E[哈希表 HashMap]
  6. E --> F[插入键值对]
  7. F --> G[查找值]
  8. F --> H[遍历键值对]

本章节介绍了结构体、枚举和集合类型的定义和使用方法，这些基础知识将为你在 Rust 编程中的数据组织和操作提供有力支持。通过实践，你会发现这些特性在构建复杂应用时非常实用。