前言

struct或 structure是一种自定义数据类型，允许您命名和包装多个相关的值，从而形成一个有意义的组合。如果您熟悉面向对象的语言，那么struct就像对象中的数据属性。在本章中，我们将比较和对比元组与结构体，在您已经知道的基础上，来演示结构体是对数据进行分组的更好方法。

我们将演示如何定义和实例化结构体，并讨论如何定义关联函数，尤其是称为方法的关联函数类型，以指定与结构类型关联的行为。您可以在程序中基于结构体和枚举创建新类型，以充分利用 Rust 的编译时类型检查。

内容

定义并实例化结构体

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

要定义结构体，我们输入关键字 struct 并命名整个结构。结构体的名称应描述组合在一起的数据片段的意义。然后，在大括号内，我们定义数据片段的名称和类型，我们称之为 字段（field）。例如，下面的代码 显示了一个存储用户帐户信息的结构。

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

为了在定义结构后使用结构体，我们通过为每个字段指定具体值来创建该结构体的实例。我们通过声明结构体的名称来创建一个实例，然后添加包含key: value （键值）对的大括号，其中key是字段的名称，value是我们想要存储在这些字段中的数据。我们不必按照在结构中声明字段的相同顺序指定字段。换言之，struct 定义类似于类型的通用模板，实例使用特定数据填充该模板以创建该类型的值。例如，我们可以声明一个特定用户，如下所示：

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

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

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

    user1.email = String::from("anotheremail@example.com");
}

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

下面的代码显示了一个 build_user函数，该函数返回一个包含给定电子邮件和用户名的 User 实例。active字段的值为 true，sign_in_count的值为 1。

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

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

字段初始化简写

当参数名称和结构字段名称完全相同，所以我们可以使用简写语法来重写 build_user，使其行为完全相同，但不会重复 username 和 email，如下所示。

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

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

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

这里我们创建了一个新的 User 结构体实例，它有一个叫做 email 的字段。我们想要将 email 字段的值设置为 build_user 函数 email 参数的值。因为 email 字段与 email 参数有着相同的名称，则只需编写 email 而不是 email: email。

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

创建一个结构体的新实例，该实例包含来自另一个实例的大部分值，但会更改一些值，这通常很有用。您可以使用 struct update语法执行此操作。
我们展示了如何在没有 update 语法的情况下定期在 user2 中创建新的 User 实例。我们为 email 设置了一个新值:

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

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

使用 struct update 语法，我们可以用更少的代码达到相同的效果，如下所示。语法 .. 指定未显式设置的其余字段应与给定实例中的字段具有相同的值。

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

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

上面的示例中，代码还在 user2 中创建了一个实例，该实例对 email 具有不同的值，但对 user1 的 username、active 和 sign_in_count 字段具有相同的值。这 ..user1 必须排在最后，以指定任何剩余的字段都应从 user1 中的相应字段获取其值，但我们可以选择以任何顺序为任意数量的字段指定值，而不管结构定义中字段的顺序如何。

请注意，结构更新语法就像带有 = 的赋值，因为它移动了数据，就像我们在“变量和数据的交互：Move”部分讲到的一样。在此示例中，创建 user2 后，我们无法再将 user1 作为一个整体使用，因为 user1 的 username 字段中的 String 已移动到 user2 中。如果我们为 user2 提供了 email 和 username 的新 String 值，因此仅使用了 user1 中的 active 和 sign_in_count 值，则 user1 在创建 user2 后仍然有效。active 和 sign_in_count 都是实现 Copy trait 的类型，所以我们在“变量和数据的交互：Clone”部分讨论的行为同样适用。

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

Rust 还支持看起来类似于元组的结构，称为元组结构。Tuples 结构具有 struct name 提供的附加含义，但没有与其字段关联的名称;相反，它们只是具有字段的类型。当您想给整个元组命名并使元组成为与其他元组不同的类型时，以及当将每个字段命名为常规结构中会很冗长或多余时，元组结构非常有用。

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

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

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);

    println!("{} {} {}", black.0, black.1, black.2);
    println!("{} {} {}", origin.0, origin.1, origin.2);
}

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

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

我们也可以定义一个没有任何字段的结构体！它们被称为类单元结构体（unit-like structs），因为它们类似于 ()，即“元组类型”一节中提到的 unit 类型。类单元结构体常常在您想要在某个类型上实现 trait 但不需要在类型中存储数据的时候发挥作用。下面是一个声明和实例化一个名为 AlwaysEqual 的 unit 结构的例子。

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

要定义 AlwaysEqual，我们使用 struct 关键字、所需的名称，然后是分号。无需大括号或圆括号！然后，我们可以以类似的方式在 subject 变量中获取 AlwaysEqual 的实例：使用我们定义的名称，不带任何大括号或圆括号。想象一下，稍后我们将实现此类型的行为，以便 AlwaysEqual 的每个实例始终等于任何其他类型的每个实例，也许为了测试目的而具有已知结果。我们不需要任何数据来实现该行为！

结构体数据的所有权

在 User 结构体定义中，我们使用了 owned String 类型而不是 &str 字符串 slice 类型。这是一个经过深思熟虑的选择，因为我们希望此结构的每个实例都拥有其所有数据，并且只要整个结构有效，该数据就有效。

结构体也可以存储对其他事物所拥有的数据的引用，但要做到这一点，需要使用 生命周期（lifetimes），生命周期可确保结构引用的数据在结构有效期间有效。假设您尝试将引用存储在 struct 中而不指定生命周期，如下所示，这不起作用：

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,
    };
}

编译器报错：

error[E0106]: missing lifetime specifier
  --> src/main.rs:68:15
   |
68 |     username: &str,
   |               ^ expected named lifetime parameter
   |
help: consider introducing a named lifetime parameter
   |
66 ~ struct User<'a> {
67 |     active: bool,
68 ~     username: &'a str,
   |

后续会讲到如何修复这个问题以便在结构体中存储引用，不过现在，我们会使用像 String 这类拥有所有权的类型来替代 &str 这样的引用以修正这个错误。