MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Rust自定义数据类型的创建

2021-07-205.2k 阅读

Rust自定义数据类型概述

在Rust编程中，自定义数据类型是一项强大的功能，它允许开发者根据实际需求创建特定的数据结构。Rust提供了多种方式来创建自定义数据类型，主要包括结构体（Structs）、枚举（Enums）和联合体（Unions，不过联合体在Rust中使用场景相对较少）。通过这些自定义数据类型，开发者可以更好地组织和管理数据，提高代码的可读性和可维护性，同时也能充分利用Rust的类型系统特性，如内存安全和类型检查等。

结构体（Structs）

结构体的定义

结构体是一种自定义数据类型，它可以将多个不同类型的数据组合在一起。结构体的定义使用 struct 关键字，后面跟着结构体的名称，然后是结构体的字段定义。例如，定义一个表示坐标点的结构体：

struct Point {
    x: i32,
    y: i32,
}

在这个例子中，Point 是结构体的名称，它有两个字段 x 和 y，类型都是 i32。字段的定义格式为 字段名: 类型。

结构体实例的创建

定义好结构体后，就可以创建结构体的实例。创建结构体实例时，需要为每个字段提供相应的值。例如：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    println!("Point x: {}, y: {}", p1.x, p1.y);
}

在 main 函数中，通过 Point { x: 10, y: 20 } 创建了一个 Point 结构体的实例 p1，然后使用 println! 宏打印出 p1 的 x 和 y 字段的值。

结构体的初始化方式

  1. 常规初始化：如上述例子，通过指定每个字段的值来初始化结构体实例。
  2. 更新语法：Rust提供了一种更新语法，允许基于一个已有的结构体实例创建新的实例，并可以选择性地更新部分字段的值。例如：
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = Point { y: 30, ..p1 };
    println!("p2 x: {}, y: {}", p2.x, p2.y);
}

在这个例子中，p2 基于 p1 创建，但是 y 字段的值被更新为 30，而 x 字段的值则继承自 p1。..p1 表示使用 p1 的剩余字段值。

结构体的方法

结构体可以拥有方法，方法是与结构体实例相关联的函数。方法的定义使用 impl 块。例如，为 Point 结构体添加一个计算到原点距离的方法：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn distance_to_origin(&self) -> f64 {
        ((self.x * self.x + self.y * self.y) as f64).sqrt()
    }
}

fn main() {
    let p = Point { x: 3, y: 4 };
    let dist = p.distance_to_origin();
    println!("Distance to origin: {}", dist);
}

在 impl Point 块中定义了 distance_to_origin 方法。方法的第一个参数通常是 &self，表示对结构体实例的不可变引用。通过 self 可以访问结构体的字段。在 main 函数中，创建了 Point 实例 p，并调用 distance_to_origin 方法计算到原点的距离并打印。

不同类型的结构体

  1. 具名结构体（Named Structs）：前面介绍的 Point 结构体就是具名结构体，它的字段都有明确的名称。
  2. 元组结构体（Tuple Structs）：元组结构体是一种特殊的结构体，它的字段没有名称，类似于元组。例如：
struct Color(i32, i32, i32);

fn main() {
    let red = Color(255, 0, 0);
    println!("Red color: {}, {}, {}", red.0, red.1, red.2);
}

这里定义了一个 Color 元组结构体，它有三个 i32 类型的字段。创建实例时，使用类似元组的语法。访问字段时，通过索引 0、1、2 等。 3. 单元结构体（Unit Structs）：单元结构体没有任何字段，类似于空元组 ()。它在某些场景下很有用，比如实现特定的trait时。例如：

struct Unit;

fn main() {
    let u = Unit;
    println!("Unit struct instance created");
}

这里定义了一个 Unit 单元结构体，并创建了一个实例 u。虽然单元结构体没有字段，但它仍然可以作为一种类型存在，并且可以实现trait。

枚举（Enums）

枚举的定义

枚举允许定义一个由一组命名常量（称为枚举成员）组成的数据类型。使用 enum 关键字来定义枚举。例如，定义一个表示星期几的枚举：

enum Day {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

在这个例子中，Day 是枚举的名称，它有七个枚举成员，分别表示一周中的每一天。

枚举实例的创建和使用

创建枚举实例时，直接使用枚举成员。例如：

enum Day {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

fn main() {
    let today = Day::Tuesday;
    match today {
        Day::Monday => println!("It's Monday"),
        Day::Tuesday => println!("It's Tuesday"),
        Day::Wednesday => println!("It's Wednesday"),
        Day::Thursday => println!("It's Thursday"),
        Day::Friday => println!("It's Friday"),
        Day::Saturday => println!("It's Saturday"),
        Day::Sunday => println!("It's Sunday"),
    }
}

在 main 函数中，创建了 Day::Tuesday 实例，并使用 match 语句根据不同的枚举成员进行不同的处理。

带数据的枚举

枚举成员不仅可以是简单的常量，还可以携带数据。例如，定义一个表示消息的枚举，消息可以是简单文本或者包含一个数字和文本：

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

这里 Quit 是一个简单的枚举成员，而 Move 携带了一个具名结构体形式的数据，Write 携带了一个 String 类型的数据，ChangeColor 携带了三个 i32 类型的数据。

枚举的方法

和结构体一样，枚举也可以有方法。通过 impl 块为枚举定义方法。例如，为 Message 枚举添加一个打印消息的方法：

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Message {
    fn print_message(&self) {
        match self {
            Message::Quit => println!("Quitting"),
            Message::Move { x, y } => println!("Moving to x: {}, y: {}", x, y),
            Message::Write(text) => println!("Writing: {}", text),
            Message::ChangeColor(r, g, b) => println!("Changing color to RGB({}, {}, {})", r, g, b),
        }
    }
}

fn main() {
    let msg1 = Message::Quit;
    msg1.print_message();

    let msg2 = Message::Move { x: 10, y: 20 };
    msg2.print_message();

    let msg3 = Message::Write("Hello, Rust!".to_string());
    msg3.print_message();

    let msg4 = Message::ChangeColor(255, 0, 0);
    msg4.print_message();
}

在 impl Message 块中定义了 print_message 方法，通过 match 语句根据不同的枚举成员打印相应的消息。在 main 函数中，创建了不同类型的 Message 实例并调用 print_message 方法。

Option枚举

Option 是Rust标准库中一个非常常用的枚举，它用于处理可能存在或不存在的值。Option 枚举定义如下：

enum Option<T> {
    Some(T),
    None,
}

这里 T 是一个类型参数，表示 Some 成员中所携带的值的类型。例如，获取一个可能为空的字符串长度：

fn get_string_length(s: Option<&str>) -> Option<usize> {
    match s {
        Some(str) => Some(str.len()),
        None => None,
    }
}

fn main() {
    let s1: Option<&str> = Some("Hello");
    let len1 = get_string_length(s1);
    println!("Length of s1: {:?}", len1);

    let s2: Option<&str> = None;
    let len2 = get_string_length(s2);
    println!("Length of s2: {:?}", len2);
}

在 get_string_length 函数中，通过 match 语句处理 Option 枚举，当 Option 为 Some 时返回字符串长度，为 None 时返回 None。在 main 函数中，分别传入 Some("Hello") 和 None 进行测试。

联合体（Unions）

联合体的定义

联合体在Rust中是一种特殊的数据类型，它允许在同一内存位置存储不同类型的数据。不过，与C语言中的联合体不同，Rust的联合体有更严格的类型安全性。联合体使用 union 关键字定义。例如：

union Number {
    i: i32,
    f: f32,
}

这里定义了一个 Number 联合体，它可以存储 i32 类型的数据或者 f32 类型的数据。

联合体的使用注意事项

  1. 内存布局：联合体的所有字段共享相同的内存空间，其大小为最大字段的大小。例如，在上述 Number 联合体中，如果 i32 和 f32 在目标平台上大小相同，那么 Number 的大小就是 i32 或 f32 的大小。
  2. 访问字段：由于联合体只有一个活动字段，访问时需要确保当前活动字段的类型与访问的字段类型一致。例如：
union Number {
    i: i32,
    f: f32,
}

fn main() {
    let mut num = Number { i: 10 };
    unsafe {
        println!("The integer value is: {}", num.i);
        num.f = 3.14;
        println!("The float value is: {}", num.f);
    }
}

在这个例子中，通过 unsafe 块访问和修改联合体的字段。因为联合体的使用可能导致未定义行为（例如，在存储 i32 后访问 f32 字段而不先修改为 f32 类型的数据），所以Rust要求在访问联合体字段时使用 unsafe 块，由开发者确保类型安全。

自定义数据类型与所有权

结构体和枚举中的所有权

当自定义数据类型包含拥有所有权的数据类型（如 String、Vec<T> 等）时，所有权规则同样适用。例如，定义一个包含 String 类型字段的结构体：

struct Person {
    name: String,
    age: i32,
}

fn main() {
    let p1 = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    let p2 = p1; // p1 的所有权转移给 p2，此时 p1 不再有效
    // println!("p1 name: {}", p1.name); // 这行代码会导致编译错误
    println!("p2 name: {}", p2.name);
}

在这个例子中，Person 结构体的 name 字段是 String 类型，当 p1 的所有权转移给 p2 时，p1 不能再被使用。

引用和生命周期

为了避免所有权转移带来的一些限制，可以使用引用。例如，定义一个包含对 String 引用的结构体：

struct NameRef<'a> {
    name: &'a String,
}

fn main() {
    let s = "Bob".to_string();
    let nr = NameRef { name: &s };
    println!("Name: {}", nr.name);
}

这里 NameRef 结构体有一个 name 字段，它是对 String 的引用。<'a> 是生命周期参数，它表示 name 引用的生命周期与 NameRef 实例的生命周期相关。在 main 函数中，创建了一个 String 实例 s，然后创建 NameRef 实例 nr，nr 中的 name 引用 s。

枚举中的所有权和生命周期

枚举中同样会涉及所有权和生命周期问题。例如，定义一个包含 String 类型数据的枚举：

enum MyEnum {
    Variant1(String),
    Variant2(i32),
}

fn main() {
    let e1 = MyEnum::Variant1("Hello".to_string());
    match e1 {
        MyEnum::Variant1(s) => println!("Variant1: {}", s),
        MyEnum::Variant2(n) => println!("Variant2: {}", n),
    }
}

在这个例子中，MyEnum::Variant1 携带了一个 String 类型的数据，在 match 语句中，s 获得了 String 的所有权。如果枚举成员包含引用类型，同样需要考虑生命周期问题，例如：

enum MyEnum<'a> {
    Variant1(&'a String),
    Variant2(i32),
}

fn main() {
    let s = "World".to_string();
    let e2 = MyEnum::Variant1(&s);
    match e2 {
        MyEnum::Variant1(ref_str) => println!("Variant1: {}", ref_str),
        MyEnum::Variant2(n) => println!("Variant2: {}", n),
    }
}

这里 MyEnum 定义了一个生命周期参数 'a，Variant1 携带了对 String 的引用，在 main 函数中，e2 中的 Variant1 引用 s，并通过 match 语句进行处理。

自定义数据类型与Trait

为自定义数据类型实现Trait

Trait 是Rust中定义共享行为的方式，我们可以为自定义数据类型实现各种Trait。例如，为 Point 结构体实现 Debug Trait，以便可以使用 println!("{:?}") 打印结构体的调试信息：

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Point(x={}, y={})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("{:?}", p);
}

在这个例子中，通过 impl fmt::Debug for Point 为 Point 结构体实现了 fmt::Debug Trait，在 fmt 方法中定义了如何格式化 Point 实例的调试信息。

自定义Trait

除了实现标准库中的Trait，还可以定义自己的Trait。例如，定义一个表示可移动对象的Trait：

trait Movable {
    fn move_to(&mut self, x: i32, y: i32);
}

struct Point {
    x: i32,
    y: i32,
}

impl Movable for Point {
    fn move_to(&mut self, x: i32, y: i32) {
        self.x = x;
        self.y = y;
    }
}

fn main() {
    let mut p = Point { x: 0, y: 0 };
    p.move_to(10, 20);
    println!("Point moved to x: {}, y: {}", p.x, p.y);
}

这里定义了 Movable Trait，它有一个 move_to 方法。然后为 Point 结构体实现了 Movable Trait，在 move_to 方法中更新 Point 的坐标。在 main 函数中，创建 Point 实例并调用 move_to 方法。

Trait对象

Trait对象允许通过动态分发来调用Trait方法。例如，定义一个 Shape Trait，并使用Trait对象来处理不同形状的面积计算：

trait Shape {
    fn area(&self) -> f64;
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

fn print_area(shape: &dyn Shape) {
    println!("Area: {}", shape.area());
}

fn main() {
    let rect = Rectangle { width: 5.0, height: 10.0 };
    let circle = Circle { radius: 3.0 };

    print_area(&rect);
    print_area(&circle);
}

在这个例子中，Shape 是一个Trait，Rectangle 和 Circle 结构体都实现了 Shape Trait。print_area 函数接受一个 &dyn Shape 类型的参数，这就是Trait对象。通过Trait对象，可以在运行时根据实际的类型调用相应的 area 方法，实现动态分发。

自定义数据类型的嵌套与组合

结构体的嵌套

结构体可以嵌套在其他结构体中，形成更复杂的数据结构。例如，定义一个表示矩形的结构体，它包含两个 Point 结构体表示矩形的左上角和右下角：

struct Point {
    x: i32,
    y: i32,
}

struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

fn main() {
    let top_left = Point { x: 0, y: 0 };
    let bottom_right = Point { x: 10, y: 10 };
    let rect = Rectangle {
        top_left,
        bottom_right,
    };
    println!("Rectangle top left: ({}, {}), bottom right: ({}, {})",
             rect.top_left.x, rect.top_left.y, rect.bottom_right.x, rect.bottom_right.y);
}

这里 Rectangle 结构体嵌套了两个 Point 结构体，通过这种方式可以方便地表示矩形的位置和大小。

枚举的嵌套

枚举也可以嵌套在结构体或其他枚举中。例如，定义一个表示图形的枚举，图形可以是圆形或矩形，矩形使用上述的 Rectangle 结构体表示：

struct Point {
    x: i32,
    y: i32,
}

struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

enum Shape {
    Circle { center: Point, radius: i32 },
    Rectangle(Rectangle),
}

fn main() {
    let circle_center = Point { x: 5, y: 5 };
    let circle = Shape::Circle { center: circle_center, radius: 3 };

    let rect_top_left = Point { x: 0, y: 0 };
    let rect_bottom_right = Point { x: 10, y: 10 };
    let rect = Rectangle {
        top_left: rect_top_left,
        bottom_right: rect_bottom_right,
    };
    let rect_shape = Shape::Rectangle(rect);

    match circle {
        Shape::Circle { center, radius } => println!("Circle at ({}, {}), radius: {}", center.x, center.y, radius),
        _ => (),
    }

    match rect_shape {
        Shape::Rectangle(rect) => println!("Rectangle top left: ({}, {}), bottom right: ({}, {})",
                                          rect.top_left.x, rect.top_left.y, rect.bottom_right.x, rect.bottom_right.y),
        _ => (),
    }
}

在这个例子中，Shape 枚举嵌套了 Rectangle 结构体，通过这种方式可以方便地表示不同类型的图形。

组合自定义数据类型

组合是一种将不同的自定义数据类型组合在一起以实现更复杂功能的方式。例如，定义一个游戏角色，它包含角色的基本信息（使用结构体表示）和当前状态（使用枚举表示）：

struct CharacterInfo {
    name: String,
    level: i32,
}

enum CharacterState {
    Idle,
    Running,
    Attacking,
}

struct Character {
    info: CharacterInfo,
    state: CharacterState,
}

fn main() {
    let info = CharacterInfo {
        name: "Warrior".to_string(),
        level: 10,
    };
    let state = CharacterState::Idle;
    let char = Character { info, state };

    match char.state {
        CharacterState::Idle => println!("{} is idle", char.info.name),
        CharacterState::Running => println!("{} is running", char.info.name),
        CharacterState::Attacking => println!("{} is attacking", char.info.name),
    }
}

在这个例子中，Character 结构体组合了 CharacterInfo 结构体和 CharacterState 枚举，通过这种组合可以全面地描述游戏角色的信息和状态。

自定义数据类型的序列化与反序列化

序列化概述

序列化是将数据结构转换为字节序列的过程，以便在网络上传输或存储到文件中。反序列化则是将字节序列恢复为原始数据结构的过程。在Rust中，常用的序列化和反序列化库有 serde。

使用serde进行序列化和反序列化

  1. 添加依赖：首先在 Cargo.toml 文件中添加 serde 和相关的序列化格式库（如 serde_json 用于JSON格式）的依赖：
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
  1. 定义可序列化的自定义数据类型：为自定义数据类型添加 serde 的派生宏 Serialize 和 Deserialize。例如：
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };

    // 序列化
    let serialized = serde_json::to_string(&p).expect("Serialization failed");
    println!("Serialized: {}", serialized);

    // 反序列化
    let deserialized: Point = serde_json::from_str(&serialized).expect("Deserialization failed");
    println!("Deserialized: x={}, y={}", deserialized.x, deserialized.y);
}

在这个例子中，Point 结构体通过 #[derive(Serialize, Deserialize)] 宏实现了 Serialize 和 Deserialize Trait。然后通过 serde_json::to_string 进行序列化，serde_json::from_str 进行反序列化。

处理复杂自定义数据类型的序列化

对于包含枚举或嵌套结构体等复杂的自定义数据类型，serde 同样能够很好地处理。例如，定义一个包含枚举和嵌套结构体的自定义数据类型并进行序列化和反序列化：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Point {
    x: i32,
    y: i32,
}

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { center: Point, radius: i32 },
    Rectangle { top_left: Point, bottom_right: Point },
}

fn main() {
    let circle_center = Point { x: 5, y: 5 };
    let circle = Shape::Circle { center: circle_center, radius: 3 };

    // 序列化
    let serialized = serde_json::to_string(&circle).expect("Serialization failed");
    println!("Serialized: {}", serialized);

    // 反序列化
    let deserialized: Shape = serde_json::from_str(&serialized).expect("Deserialization failed");
    match deserialized {
        Shape::Circle { center, radius } => println!("Deserialized circle at ({}, {}), radius: {}", center.x, center.y, radius),
        _ => (),
    }
}

这里 Shape 枚举包含嵌套的 Point 结构体，通过 serde 的派生宏和 serde_json 库可以方便地进行序列化和反序列化。

自定义数据类型在实际项目中的应用

游戏开发中的应用

在游戏开发中，自定义数据类型可以用于表示游戏对象、角色、场景等。例如，使用结构体表示游戏角色的属性，枚举表示角色的动作状态：

struct CharacterAttributes {
    health: u32,
    attack_power: u32,
    defense: u32,
}

enum CharacterAction {
    Idle,
    Move,
    Attack,
    Defend,
}

struct Character {
    name: String,
    attributes: CharacterAttributes,
    action: CharacterAction,
}

fn main() {
    let attrs = CharacterAttributes {
        health: 100,
        attack_power: 20,
        defense: 10,
    };
    let char = Character {
        name: "Knight".to_string(),
        attributes: attrs,
        action: CharacterAction::Idle,
    };

    // 根据角色状态进行不同处理
    match char.action {
        CharacterAction::Idle => println!("{} is idle", char.name),
        CharacterAction::Move => println!("{} is moving", char.name),
        CharacterAction::Attack => println!("{} is attacking", char.name),
        CharacterAction::Defend => println!("{} is defending", char.name),
    }
}

通过这种方式，可以清晰地描述游戏角色的各种信息和状态，方便在游戏逻辑中进行处理。

网络编程中的应用

在网络编程中，自定义数据类型可用于表示网络消息。例如，定义一个表示登录请求的结构体，通过序列化发送到服务器：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct LoginRequest {
    username: String,
    password: String,
}

fn main() {
    let request = LoginRequest {
        username: "user1".to_string(),
        password: "pass123".to_string(),
    };

    // 假设这里使用serde_json进行序列化并发送到网络
    let serialized = serde_json::to_string(&request).expect("Serialization failed");
    println!("Serialized login request: {}", serialized);
}

在服务器端，接收到字节序列后进行反序列化得到原始的 LoginRequest 结构体，从而处理登录逻辑。

数据处理和分析中的应用

在数据处理和分析场景中，自定义数据类型可以用于表示特定的数据格式。例如，定义一个表示股票交易数据的结构体：

struct StockTrade {
    symbol: String,
    trade_time: String,
    price: f64,
    volume: u32,
}

fn main() {
    let trade = StockTrade {
        symbol: "AAPL".to_string(),
        trade_time: "2023-10-01 10:00:00".to_string(),
        price: 150.5,
        volume: 1000,
    };

    // 可以在这里进行数据处理和分析，如计算总交易额
    let total_value = trade.price * trade.volume as f64;
    println!("Total value of trade: {}", total_value);
}

通过自定义数据类型，可以将股票交易的各个数据字段组合在一起，方便进行各种数据处理和分析操作。

通过以上对Rust自定义数据类型的详细介绍，包括结构体、枚举、联合体的定义、使用、与所有权、Trait的关系，以及在实际项目中的应用等方面，希望开发者能够充分掌握这一强大的功能，编写出更高效、安全和可维护的Rust代码。在实际应用中，根据具体需求合理选择和设计自定义数据类型，将有助于提升程序的质量和性能。