定义和实例化结构


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


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


文件名： src/main.rs 
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}

示例 5-1：User 结构体定义


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


文件名： 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,
    };
}

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


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


文件名： 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");
}

示例 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 实例


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


使用 Field init 简写


因为示例 5-4 中的参数名和 struct 字段名是完全一样的，所以我们可以使用 field init 简写语法来重写 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：一个使用 field init 简写的 build_user 函数，因为 username 和 email 参数与 struct fields 同名


在这里，我们将创建 User 结构的新实例，该实例具有一个名为 email 的字段。我们希望将 email 字段的值设置为 email build_user参数。由于 email 字段和 email 参数具有相同的名称，因此我们只需要编写 email 而不是 email： email。


使用 Struct Update 语法从其他实例创建实例


创建包含大部分 的值，但会更改一些值。您可以使用 struct update 语法。


首先，在示例 5-6 中，我们展示了如何在 user2 中创建新的 User 实例 ，没有 UPDATE 语法。我们为 email 设置了一个新值，但使用示例 5-2 中创建的 user1 中的相同值。


文件名： 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,
    };
}

示例 5-6：使用 user1 中除一个值之外的所有值创建新的 User 实例


使用 struct update 语法，我们可以用更少的代码达到相同的效果，如图 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：使用 struct update 语法为 User 实例设置新的 email 值，但使用 user1 的其余值


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


请注意，struct update 语法使用 = 就像赋值一样;这是因为它移动了数据，就像我们在“变量和数据交互 移动“部分。在这个例子中，我们不能再使用 user1 作为一个整体，因为 user1 的 username 字段已移至 user2 中。如果我们给 user2 新的 string 值，因此只使用了 active 并从 user1 sign_in_count值，则 user1 在创建 user2 后仍然有效。active 和 sign_in_count 都是实现 Copy trait 的类型，因此我们在“仅堆栈 Data： Copy“部分将适用。我们仍然可以使用 user1.email，因为它的值没有移出。


使用不带命名字段的 Tuple 结构创建不同的类型


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


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


文件名： 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 组成 值。否则，元组结构实例类似于元组，因为你可以 将它们解构为单独的部分，您可以使用 .后跟索引来访问单个值。


没有任何字段的类似 Unit 的结构体


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


文件名： src/main.rs 
struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}


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


结构体数据的所有权


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


结构体也可以存储对其他事物所拥有的数据的引用，但要做到这一点，需要使用 lifetimes，我们将在第 10 章讨论 Rust 的一个特性。生命周期可确保结构引用的数据在结构有效期间有效。假设你尝试将引用存储在 struct 中而不指定生命周期，如下所示;这不起作用：


文件名： 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 这样的引用来修复此类错误。