跳到主要内容

Rust 结构体

提示
  1. 结构体的定义与用途：Rust结构体是用户定义的数据类型，允许将不同类型的数据组合在一起，如存储个人信息（名字、年龄、身高）。
  2. 结构体实例化与字段访问：通过指定字段值来实例化结构体，然后使用点.运算符访问这些字段，如person.name访问name字段。
  3. 结构体解构与可变性：可以解构结构体以分解为更小的变量，使用let Person { name, age, height } = person;。若需修改结构体，声明时加mut关键字。

Rust 结构体或结构是用户定义的数据类型，用于将不同类型的数据存储在一起。

假设我们想存储一个人的名字、年龄和身高。为此，我们可以为每个属性/字段创建变量。

let personName: String = String::from("John Doe");
let personAge: u8 = 18;
let personHeight: u8 = 178;

这种方法的问题在于我们必须分别维护所有这些变量。要为多个人存储这些字段，我们将不得不为每个人创建不同的变量。

相反，我们可以创建一个结构体，将所有字段作为一个单元存储在一起。例如，

struct Person {
    name: String,
    age: u8,
    height: u8
}

在 Rust 中定义结构体​

在 Rust 中，我们使用 struct 关键字来定义结构。结构的语法是：

struct struct_name {
    field1: data_type,
    field2: data_type,
    field3: data_type
}

这里，

  • struct - 定义结构的关键字
  • struct_name - 结构的名称
  • field1: data_type/field2: data_type - 结构内部字段的名称和数据类型。

让我们看一个例子。

struct Person {
    name: String,
    age: u8,
    height: u8
}

这里，我们定义了一个名为 Person 的结构体。它包含三个字段：

  • name - 数据类型为 String
  • age - 数据类型为 u8
  • height - 数据类型为 u8

实例化 Rust 结构体​

要在 Rust 中使用结构体，我们首先必须创建结构体的实例。例如，

// 定义一个结构体
struct Person {
    name: String
    age: u8,
    height: u8
}

// 创建 Person 结构体的一个实例
let person1 = Person {
    ...
};

这里，Person {...} 创建了 Person 结构体 的一个实例，我们将其赋值给了 person1 变量。

我们在创建实例时也可以为结构体字段赋值。例如，

let person1 = Person {
    name: String::from("John Doe"),
    age: 18,
    height: 178
};

这里，我们初始化了 Person 结构体的 name、age 和 height 字段的值。这个初始化结构体字段值的过程被称为 结构体的实例化。

注意： 结构体定义是一个模板，结构体实例用数据填充这个模板。

访问结构体的字段​

我们可以使用结构体实例和点 . 符号来访问结构体中字段的值。例如，

fn main() {
    // 定义一个 Person 结构体
    struct Person {
        name: String,
        age: u8,
        height: u8
    }

    // 实例化 Person 结构体
    let person = Person {
        name: String::from("John Doe"),
        age: 18,
        height: 178
    };

    // 访问 Person 结构体中 name 字段的值
    println!("Person name = {}", person.name);

    // 访问 Person 结构体中 age 字段的值
    println!("Person age = {}", person.age);

    // 访问 Person 结构体中 height 字段的值
    println!("Person height = {}", person.height);
}

输出

人名 = John Doe
年龄 = 18
身高 = 178

这里，

  • person.name - 读取 Person 结构体的 name 字段（John Doe）
  • person.age - 读取 age 字段（18）
  • person.height - 读取 height 字段（178）

Rust 结构体字段的解构​

解构是将数据类型（数组、元组等）的字段分解为较小变量的过程。我们可以在 Rust 中将结构体的字段分解为较小的变量。

假设我们有一个结构体和一个结构体实例，

struct Person {
    name: String,
    age: u8,
    height: u8
}

let person = Person {
    name: String::from("John Doe"),
    age: 18,
    height: 178
};

我们现在可以使用以下方法进行解构：

// 解构 Person 结构体
let Person { name, age, height } = person;

现在，我们可以直接使用字段名称访问 name、age 和 height 字段：

  • 使用 name 而不是 person.name
  • 使用 age 而不是 person.age
  • 使用 height 而不是 person.height

但是，请注意，解构时变量的名称应与字段的名称相同。

示例：结构体字段的解构​

fn main() {
    // 定义一个 Person 结构体
    struct Person {
        name: String,
        age: u8,
        height: u8
    }

    // 实例化 Person 结构体
    let person = Person {
        name: String::from("John Doe"),
        age: 18,
        height: 178
    };

    // 将 Person 结构体解构为 name、age 和 height 变量
    let Person { name, age, height } = person;

    println!("人名 = {}", name);
    println!("年龄 = {}", age);
    println!("身高 = {}", height);
}

输出

人名 = John Doe
年龄 = 18
身高 = 178

在这里，解构发生在这个表达式中，

let Person { name, age, height } = person;

左侧的模式有声明，而表达式的右侧有一个结构体实例。

在表达式的左侧，我们为 Person 结构体的字段 name、age 和 height 进行 let 声明。在表达式的右侧，我们赋值给实例化的 Person 结构体。

结果，我们得到了这个人的 name、age 和 height，并将其打印到屏幕上。

常见问题​

如何在 Rust 中创建一个可变结构体？

要创建一个可变的 struct，我们在声明结构体变量时使用 mut 关键字。例如，

fn main() {
    // 定义一个 Point 结构体
    struct Point {
        x: i32,
        y: i32,
    }

    // 实例化 Point 结构体为一个可变结构体变量
    let mut point = Point { x: 0, y: 0 };

    println!("更改前：");
    println!("Point x = {}", point.x);
    println!("Point y = {}", point.y);

    // 更改可变 point 结构体中的 x 字段值
    point.x = 5;

    println!();
    println!("更改后：");
    println!("Point x = {}", point.x);
    println!("Point y = {}", point.y);
}

输出

更改前：
Point x = 0
Point y = 0

更改后：
Point x = 5
Point y = 0

什么是元组结构体？

元组结构体是 tuple 和 struct 之间的混合体。所有的元组结构体都有名字，但它们的字段没有。例如，

fn main() {
    // 一个元组结构体
    #[derive(Debug)]
    struct Point(i32, i32);

    // 使用值实例化一个元组结构体
    let point = Point(1, 2);

    println!("{:?}", point);
}

输出

Point(1, 2)

这里，struct Point(i32, i32) 是一个有两个 i32 类型字段的元组结构体。

注意： 在结构体定义上方添加 #[derive(Debug)]，以允许 Rust 打印整个结构体。

最后于 更新