Rust中的Enum与Struct示例详解

更新时间：2025年10月27日 09:37:41 作者：alwaysrun

在 Rust 中,struct（结构体）和enum（枚举）是两种核心的自定义类型,分别用于组合相关数据和表示互斥的可能性,这篇文章主要介绍了Rust中的Enum与Struct示例,需要的朋友可以参考下

结构体struct

struct用于将多个相关的值组合在一起，形成一个有意义的组

具名结构体(named strcut)

最常用的结构体形式，字段有明确的名称，可读性强，适合数据含义明确的场景。

字段默认私有（仅当前模块内可见）
通过impl实现关联函数（方法）
通过..实现赋值（所有未指定的字段，全部替换为…对应变量中的）：若字段为移动语义，所有权被移走
通过trait实现多态（参见《Rust中的特征Trait》）

use std::fmt;
pub struct Person {
    pub name: String,
    age: u8,
    active: bool,
}
impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Person {{ name: {}, age: {}, active: {} }}", self.name, self.age, self.active)
    }
}
fn main() {
    let alice = Person { name: String::from("Alice"), age: 30, active: true };
    let mike = Person { name: String::from("Mike"), ..alice };
    println!("person: {}", mike);
    // 解结构与..
    let Person { name, .. } = mike;
    println!("name: {}", name);
}

可见性

默认为私有，可通过pub修饰符修改：

修饰符	可见范围	说明
`pub`	全局可见（跨 crate）	完全公开
`pub(crate)`	整个当前 crate 内可见	库内部共享
`pub(super)`	父模块可见	子模块辅助函数
`pub(in path)`	指定模块路径内可见	最灵活的控制
（无修饰）	当前模块私有	默认私有

trait(继承/多态)

Rust 没有传统 OOP 的类继承（没有基类/子类）。用 trait + impl 来实现接口/多态。

trait定义方法签名集合，实现trait的类必须提供所有对应方法：

静态分发（T: Trait）在编译期确定具体类型（单态化，性能好）。
动态分发（&dyn Trait 或 Box<dyn Trait>）通过虚函数表(vtable)，在运行时分发（适合异构集合/插件式架构）。

trait Drawable {
    fn draw(&self);
}
struct Circle { radius: f64 }
struct Square { side: f64 }
impl Drawable for Circle {
    fn draw(&self) { println!("circle r={}", self.radius); }
}
impl Drawable for Square {
    fn draw(&self) { println!("square s={}", self.side); }
}
// 静态分发（泛型）
fn draw_all<T: Drawable>(items: &[T]) {
    for item in items { item.draw(); }
}
// 动态分发（trait object）
fn draw_box(items: &[Box<dyn Drawable>]) {
    for item in items { item.draw(); }
}

泛型与生命周期

结构体可以是泛型的（参见《Rust中的泛型Generics》），也可以带生命周期参数。

struct Holder<'a, T> { r: &'a T, val: T }
struct Pair<T, U>(T, U);

泛型说明：

特性	说明
`struct Point<T>`	定义泛型结构体
`impl<T> Point<T>`	为所有类型实现方法
`impl Point<i32>`	为特定类型实现方法
`T: Display`	泛型约束，要求类型实现`Display`trait
`where T: Clone, U: Debug`	泛型约束，更清晰的约束语法

元组结构体(tuple struct)

字段没有名称，仅通过位置区分，适合数据结构简单、字段含义可通过位置推断的场景。

// 元组结构体：通过位置区分（x, y）
struct Point(i32, i32);  
// 创建实例
let p1 = Point(3, 4);
// 访问字段（通过索引）
println!("x坐标：{}", p1.0);  // 输出：x坐标：3

单元结构体(unit struct)

一种不包含任何字段的结构体。它的定义形式类似于一个“空”的结构体：

在内存中不占用任何空间（size_of::<UnitStruct>() == 0）
主要用于标记类型（表示 “存在性” 而非 “数据”）

// 定义状态
pub struct Locked;
pub struct Unlocked;
// 门的结构，使用泛型参数表示状态
pub struct Door<TState> {
    id: u32,
    _state: std::marker::PhantomData<TState>,
}
// 只有 Locked 状态才能解锁
impl Door<Locked> {
    fn unlock(self) -> Door<Unlocked> {
        println!("门 {} 已解锁", self.id);
        Door {
            id: self.id,
            _state: std::marker::PhantomData,
        }
    }
}
// 只有 Unlocked 状态才能打开
impl Door<Unlocked> {
    fn open(&self) {
        println!("门 {} 打开", self.id);
    }
    fn lock(self) -> Door<Locked> {
        println!("门 {} 已上锁", self.id);
        Door {
            id: self.id,
            _state: std::marker::PhantomData,
        }
    }
}
pub fn test_door() {
    let door = Door::<Locked> {
        id: 101,
        _state: std::marker::PhantomData,
    };    
    let door = door.unlock(); // 状态转换
    door.open(); // Unlocked 状态可以打开
    let door = door.lock(); // 重新上锁
}

枚举(enum)

枚举的核心作用是定义一个类型，其值是有限的、互斥的几种可能变体（variants）之一。每个变体可以关联不同类型和数量的数据。

枚举通过enum关键字定义，每个变体可以是 “空” 的，也可以携带数据（类似元组或结构体）。

// 定义枚举：消息类型
enum Message {
    Quit,  // 无数据：退出消息
    Move { x: i32, y: i32 },  // 具名数据：移动到(x,y)
    Write(String),  // 元组数据：写入文本
    ChangeColor(i32, i32, i32),  // 元组数据：修改颜色（RGB）
}
// 创建枚举实例
let msg1 = Message::Quit;  // 退出消息
let msg2 = Message::Move { x: 10, y: 20 };  // 移动到(10,20)
let msg3 = Message::Write(String::from("hello"));  // 写入"hello"

模式匹配

枚举的核心用法是通过match表达式匹配其变体，从而处理不同情况（类似 “多分支条件判断”，但更安全）。

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("收到退出消息"),
        Message::Move { x, y } => println!("移动到坐标：({}, {})", x, y),
        Message::Write(text) => println!("写入内容：{}", text),
        Message::ChangeColor(r, g, b) => println!("修改颜色为 RGB({}, {}, {})", r, g, b),
    }
}
process_message(msg2);  // 输出：移动到坐标：(10, 20)
process_message(msg3);  // 输出：写入内容：hello

常见enum

Option<T>是 Rust 中用于表示 “有值” 或 “无值” 的枚举，彻底避免了空指针（Null）问题。

enum Option<T> {
    Some(T),  // 有值：存储类型为T的值
    None,     // 无值
}

Result<T, E>用于表示操作 “成功” 或 “失败” 的结果，是 Rust 错误处理的核心类型。

enum Result<T, E> {
    Ok(T),   // 成功：存储类型为T的结果
    Err(E),  // 失败：存储类型为E的错误信息
}

Ordering用于表示两个值的比较结果（小于、等于、大于）

enum Ordering {
    Less,    // 小于
    Equal,   // 等于
    Greater, // 大于
}

到此这篇关于Rust中的Enum与Struct示例详解的文章就介绍到这了,更多相关Rust Enum与Struct内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Rust搭建webserver的底层原理与应用实战技巧
本文介绍Rust在HTTP编程中的应用,涵盖协议基础、标准库与第三方库（如hyper、reqwest）的使用,以及多线程服务器和线程池的实现与关闭机制,展示Rust在性能、安全和并发方面的优势,感兴趣的朋友跟随小编一起看看吧
2025-06-06
Rust读取配置文件的实现
本文主要介绍了Rust读取配置文件的实现,主要读取Cargo.toml文件,读取.env文件和读取自定义toml文件这三种,具有一定的参考价值,感兴趣的可以了解一下
2024-03-03
Rust循环控制结构用法详解
Rust提供了多种形式的循环结构,每种都适用于不同的场景,在Rust中,循环有三种主要的形式：loop、while和for,本文将介绍Rust中的这三种循环,并通过实例展示它们的用法和灵活性,感兴趣的朋友一起看看吧
2024-02-02
使用环境变量实现Rust程序中的不区分大小写搜索方式
本文介绍了如何在Rust中实现不区分大小写的搜索功能,并通过测试驱动开发（TDD）方法逐步实现该功能,通过修改运行函数和获取环境变量,程序可以根据环境变量控制搜索模式
2025-02-02
Rust控制流运算符match的用法详解
match 是Rust中一个极为强大的控制流运算符,用于模式匹配和控制流的选择,它允许将一个值与一系列的模式相比较,根据匹配的模式执行相应代码,本文给大家详细介绍了Rust控制流运算符match的用法,需要的朋友可以参考下
2024-01-01
Rust Aya 框架编写 eBPF 程序
这篇文章主要介绍了Rust Aya 框架编写 eBPF 程序方法的相关资料,需要的朋友可以参考下
2022-11-11
解读Rust的Rc<T>:实现多所有权的智能指针方式
Rc<T> 是 Rust 中用于多所有权的引用计数类型,通过增加引用计数来管理共享数据,只有当最后一个引用离开作用域时,数据才会被释放,Rc<T> 适用于单线程环境,并且只允许不可变共享数据；需要可变共享时应考虑使用 RefCell<T> 或其他解决方案
2025-02-02
Rust在Android端集成使用详解
本文介绍了如何在Android平台上调用Rust编写的组件,详细说明了开发环境的搭建、Rust库的创建、配置和编译过程,以及如何在Android应用中使用Rust编写的代码,文中提到飞书底层使用Rust编写通用组件,展示了Rust在移动端开发中的应用价值
2024-11-11
Rust处理命令行参数
在Rust中,命令行参数是程序从命令行接收的输入,它们为程序提供了运行时配置和数据的灵活性,本文就来介绍一下Rust处理命令行参数,具有一定的参考价值,感兴趣的可以了解一下
2024-03-03
在Rust应用中访问.ini格式的配置文件方式
Rust应用中访问.ini格式的配置文件,可以使用ini或config库,以ini库为例,在Cargo.toml中添加依赖,然后在代码中读取和解析ini文件,确保配置文件路径正确,使用section和get方法访问配置值
2025-02-02