Rust 程序设计语言

定义和实例化结构体

结构体类似于元组，在 “元组类型”章节中讨论过，两者都持有多个相关的值。与元组一样，结构体的各个部分可以是不同的类型。与元组不同的是，在结构体中，您将命名每个数据片段，以便清楚地了解值的含义。添加这些名称意味着结构体比元组更灵活：您不必依赖数据的顺序来指定或访问实例的值。

要定义结构体，我们输入关键字 struct 并命名整个结构体。结构体的名称应描述组合在一起的数据片段的重要性。然后，在花括号内，我们定义数据片段的名称和类型，我们称之为字段。例如，列表 5-1 显示了一个存储有关用户帐户信息的结构体。

文件名：src/main.rs

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

fn main() {}

列表 5-1：User 结构体定义

要在定义结构体后使用它，我们通过为每个字段指定具体值来创建该结构体的实例。我们通过声明结构体的名称，然后添加包含 键: 值 对的花括号来创建实例，其中键是字段的名称，值是我们想要存储在这些字段中的数据。我们不必按照在结构体中声明字段的顺序来指定字段。换句话说，结构体定义就像类型的通用模板，而实例用特定数据填充该模板以创建类型的值。例如，我们可以声明一个特定用户，如列表 5-2 所示。

列表 5-2：创建 User 结构体的实例

要从结构体获取特定值，我们使用点表示法。例如，要访问此用户的电子邮件地址，我们使用 user1.email。如果实例是可变的，我们可以通过使用点表示法并赋值给特定字段来更改值。列表 5-3 显示了如何更改可变 User 实例的 email 字段中的值。

列表 5-3：更改 User 实例的 email 字段中的值

请注意，整个实例必须是可变的；Rust 不允许我们仅将某些字段标记为可变的。与任何表达式一样，我们可以构造结构体的新实例作为函数体中的最后一个表达式，以隐式返回该新实例。

列表 5-4 显示了一个 build_user 函数，该函数返回一个具有给定电子邮件和用户名的 User 实例。active 字段获取值 true，sign_in_count 获取值 1。

文件名：src/main.rs

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

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username: username,
        email: email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

列表 5-4：一个 build_user 函数，它接受电子邮件和用户名并返回 User 实例

用与结构体字段相同的名称命名函数参数是有意义的，但是不得不重复 email 和 username 字段名称和变量有点乏味。如果结构体有更多字段，重复每个名称会变得更加烦人。幸运的是，有一个方便的简写！

使用字段初始化简写

由于列表 5-4 中的参数名称和结构体字段名称完全相同，我们可以使用字段初始化简写语法来重写 build_user，使其行为完全相同，但没有 username 和 email 的重复，如列表 5-5 所示。

文件名：src/main.rs

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

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

列表 5-5：一个 build_user 函数，它使用字段初始化简写，因为 username 和 email 参数与结构体字段同名

在这里，我们正在创建一个新的 User 结构体实例，它有一个名为 email 的字段。我们想要将 email 字段的值设置为 build_user 函数的 email 参数中的值。由于 email 字段和 email 参数具有相同的名称，我们只需要写 email 而不是 email: email。

使用结构体更新语法从其他实例创建实例

通常，创建一个新的结构体实例很有用，该实例包含来自另一个实例的大部分值，但更改了一些值。您可以使用结构体更新语法来执行此操作。

首先，在列表 5-6 中，我们展示了如何使用常规方法在 user2 中创建一个新的 User 实例，而没有更新语法。我们为 email 设置了一个新值，但其他方面使用了列表 5-2 中创建的 user1 中的相同值。

列表 5-6：使用来自 user1 的除一个值以外的所有值创建新的 User 实例

使用结构体更新语法，我们可以用更少的代码实现相同的效果，如列表 5-7 所示。语法 .. 指定未显式设置的剩余字段应具有与给定实例中字段相同的值。

文件名：src/main.rs

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

fn main() {
    // --snip--

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

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

列表 5-7：使用结构体更新语法为 User 实例设置新的 email 值，但使用来自 user1 的其余值

列表 5-7 中的代码还在 user2 中创建了一个实例，该实例的 email 值不同，但 username、active 和 sign_in_count 字段的值与 user1 相同。..user1 必须放在最后，以指定任何剩余字段都应从 user1 中的相应字段获取其值，但是我们可以选择为任意数量的字段指定值，顺序不限，而与结构体定义中字段的顺序无关。

请注意，结构体更新语法使用 = 就像赋值一样；这是因为它移动了数据，正如我们在 “什么是所有权？”章节中看到的那样。在本例中，在创建 user2 之后，user1 部分失效，因为 user1 的 username 字段中的 String 已移动到 user2 中。如果我们为 user2 提供了新的 String 值用于 email 和 username，因此仅使用了来自 user1 的 active 和 sign_in_count 值，那么在创建 user2 之后，user1 仍然完全有效。active 和 sign_in_count 的类型是实现 Copy trait 的类型，因此我们在 “复制 vs. 从集合中移出”章节中讨论的行为将适用。

使用没有命名字段的元组结构体来创建不同的类型

Rust 也支持看起来类似于元组的结构体，称为元组结构体。元组结构体具有结构体名称提供的附加含义，但没有与字段关联的名称；相反，它们只有字段的类型。当您想要给整个元组一个名称并使元组与其他元组成为不同的类型，并且当像常规结构体中那样命名每个字段会显得冗长或冗余时，元组结构体非常有用。

要定义元组结构体，请以 struct 关键字和结构体名称开头，后跟元组中的类型。例如，这里我们定义并使用了两个名为 Color 和 Point 的元组结构体

文件名：src/main.rs

请注意，black 和 origin 值是不同的类型，因为它们是不同元组结构体的实例。您定义的每个结构体都是其自己的类型，即使结构体中的字段可能具有相同的类型。例如，接受 Color 类型参数的函数不能接受 Point 作为参数，即使两种类型都由三个 i32 值组成。否则，元组结构体实例类似于元组，因为您可以将它们解构为单独的部分，并且可以使用 . 后跟索引来访问单个值。

没有任何字段的单元结构体

您还可以定义没有任何字段的结构体！这些被称为单元结构体，因为它们的行为类似于 ()，我们在 “元组类型”章节中提到的单元类型。当您需要在某些类型上实现 trait 但没有任何要存储在类型本身中的数据时，单元结构体可能很有用。我们将在第 10 章中讨论 trait。以下是声明和实例化名为 AlwaysEqual 的单元结构体的示例

要定义 AlwaysEqual，我们使用 struct 关键字，想要的名称，然后是分号。无需花括号或括号！然后，我们可以以类似的方式在 subject 变量中获取 AlwaysEqual 的实例：使用我们定义的名称，而无需任何花括号或括号。想象一下，稍后我们将为此类型实现行为，以便 AlwaysEqual 的每个实例始终等于任何其他类型的每个实例，可能是为了获得已知的测试结果。我们不需要任何数据来实现该行为！您将在第 10 章中看到如何定义 trait 并将它们实现在任何类型上，包括单元结构体。

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

fn main() {
    let user1 = User {
        active: true,
        username: "someusername123",
        email: "someone@example.com",
        sign_in_count: 1,
    };
}

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     username: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 ~     username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 |     username: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` (bin "structs") due to 2 previous errors

借用结构体的字段

类似于我们在 “不同的元组字段” 中的讨论，Rust 的借用检查器将在结构体级别和字段级别跟踪所有权权限。例如，如果我们借用 Point 结构的字段 x，则 p 和 p.x 都将暂时失去它们的权限（但不包括 p.y）

因此，如果我们尝试在 p.x 被可变借用时使用 p，如下所示

那么编译器将拒绝我们的程序并显示以下错误

error[E0502]: cannot borrow `p` as immutable because it is also borrowed as mutable
  --> test.rs:10:17
   |
9  |     let x = &mut p.x;
   |             -------- mutable borrow occurs here
10 |     print_point(&p);
   |                 ^^ immutable borrow occurs here
11 |     *x += 1;
   |     ------- mutable borrow later used here

更一般而言，如果您遇到涉及结构体的所有权错误，则应考虑结构的哪些字段应该以哪些权限借用。但请注意借用检查器的局限性，因为 Rust 有时可能会假设借用的字段比实际借用的字段更多。