定义和实例化结构体

结构体类似于在“元组类型”部分讨论的元组，因为它们都包含多个相关值。像元组一样，结构体的各个部分可以是不同的类型。与元组不同，在结构体中，您将为每个数据片段命名，以便明确值的含义。添加这些名称意味着结构体比元组更灵活：您不必依赖数据的顺序来指定或访问实例的值。

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

Filename: src/main.rs 
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}
Listing 5-1: A User struct definition

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

Filename: src/main.rs 
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}
Listing 5-2: Creating an instance of the User struct

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

Filename: src/main.rs 
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

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");
}
Listing 5-3: Changing the value in the email field of a User instance

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

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

Filename: 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"),
    );
}
Listing 5-4: A build_user function that takes an email and username and returns a User instance

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

使用字段初始化简写

因为参数名称和结构体字段名称在清单 5-4 中完全相同，我们可以使用 字段初始化简写 语法重写 build_user，使其行为完全相同，但不会重复 username 和 email，如清单 5-5 所示。

Filename: 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"),
    );
}
Listing 5-5: A build_user function that uses field init shorthand because the username and email parameters have the same name as struct fields

这里，我们正在创建一个 User 结构体的新实例，该结构体有一个名为 email 的字段。我们希望将 email 字段的值设置为 build_user 函数的 email 参数的值。因为 email 字段和 email 参数名称相同，所以我们只需要写 email 而不是 email: email。

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

通常很有用的是创建一个结构体的新实例，该实例包含另一个实例的大多数值，但更改了一些值。你可以使用结构更新语法来实现这一点。

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

Filename: 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 {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}
Listing 5-6: Creating a new User instance using all but one of the values from user1

通过使用结构体更新语法，我们可以用更少的代码实现相同的效果，如清单 5-7 所示。语法 .. 指定未明确设置的其余字段应具有给定实例中字段的相同值。

Filename: 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
    };
}
Listing 5-7: Using struct update syntax to set a new email value for a User instance but to use the rest of the values from user1

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

请注意，结构体更新语法使用 = 类似于赋值；这是因为 它会移动数据，就像我们在 “变量和数据的移动交互” 部分看到的那样。在这个例子中，创建 user2 之后，我们不能再使用整个 user1，因为 user1 中 username 字段的 String 被移动到了 user2。如果我们为 user2 的 email 和 username 都提供了新的 String 值，因此只使用了 user1 的 active 和 sign_in_count 值，那么在创建 user2 之后 user1 仍然有效。active 和 sign_in_count 都是实现了 Copy 特性的类型，因此我们在 “仅栈数据：复制” 部分讨论的行为将适用。我们仍然可以使用 user1.email，因为它的值 没有 被移出。

使用无命名字段的元组结构体创建不同类型的实例

Rust 还支持看起来类似于元组的结构体，称为 元组结构体。元组结构体具有结构体名称提供的附加含义，但它们的字段没有名称；相反，它们只有字段的类型。当您希望为整个元组命名并使该元组与其他元组类型不同，以及在常规结构体中为每个字段命名会显得冗长或重复时，元组结构体非常有用。

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

Filename: src/main.rs 
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

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

请注意，black 和 origin 值是不同类型的，因为它们是不同元组结构体的实例。你定义的每个结构体都是其自己的类型，即使结构体内的字段可能具有相同的类型。例如，一个接受 Color 类型参数的函数不能接受一个 Point 作为参数，即使这两种类型都由三个 i32 值组成。除此之外，元组结构体实例类似于元组，你可以将它们解构为单独的部分，可以使用 . 加上索引来访问单个值。与元组不同，元组结构体在解构时需要指定结构体的类型。例如，我们会写 let Point(x, y, z) = point。

没有字段的单元结构体

你也可以定义没有字段的结构体！这些被称为单元类结构体，因为它们的行为类似于()，即我们在“元组类型”部分提到的单元类型。单元类结构体在你需要在某些类型上实现特质但不想在类型本身中存储任何数据时非常有用。我们将在第10章讨论特质。以下是一个声明和实例化名为AlwaysEqual的单元结构体的示例：

Filename: src/main.rs 
struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

要定义 AlwaysEqual，我们使用 struct 关键字，我们想要的名字，然后是一个分号。不需要花括号或括号！然后我们可以通过类似的方式在 subject 变量中获取 AlwaysEqual 的实例：使用我们定义的名字，不需要任何花括号或括号。想象一下，稍后我们将为这种类型实现行为，使得每个 AlwaysEqual 的实例都等于任何其他类型的每个实例，也许是为了在测试中有一个已知的结果。实现这种行为我们不需要任何数据！你将在第 10 章中看到如何定义特质并在任何类型上实现它们，包括单元结构体。

结构体数据的所有权

在清单 5-1 的 User 结构体定义中，我们使用了拥有型的 String 而不是 &str 字符串切片类型。这是一个有意的选择，因为我们希望这个结构体的每个实例都拥有其所有数据，并且这些数据的有效期与整个结构体的有效期一样长。

也可以让结构体存储对其他所有者数据的引用，但这样做需要使用生命周期，这是我们在第10章将讨论的Rust特性。生命周期确保结构体引用的数据在结构体存在期间都是有效的。假设你尝试在结构体中存储一个引用而不指定生命周期，如下所示；这是行不通的：

Filename: src/main.rs 
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

在第 10 章中，我们将讨论如何修复这些错误，以便您可以在结构体中存储引用，但目前，我们将使用拥有类型如 String 而不是引用如 &str 来修复此类错误。