Rust枚举和结构体

定义结构体

// 普通结构体
struct User {
    username: String,
    age: u8,
    email: String
}

// 元组结构体，字段无名
struct Point(i32, i32, i32);

// 单元结构体，无字段
struct Empty;

// 实例化
let user = User{ username: "rust", age: 10, email: "user@Rust.com"};
let point = Point(0, 0, 0)
let empty = Empty;

println!("用户名: {}", user1.username);

// 更新语法
let user2 = User{ username: "cpp", ..user}; // 使用user初始化其他字段

// 方法实现
impl User {
    // 关联函数类似静态方法
    // Self表示当前结构体的类型，等同于结构体名
    fn new(email: String, username: String) -> Self {
        return User{username, email, age: 10};
    }
    // 实例方法
    fn get_email(&self) -> &str {
        return &self.eamil;
    }
}

// 泛型
struct Pair<T, U> {
    first: T,
    second: U
}

// trait
trait  Drawable {
    fn draw(&self);
}

struct Circle{
  radius: f64
}

impl Drawable for Circle {
    fn draw(&self) {
        println!("draw circle, radius: {}", self.radius);
    }
}

定义枚举

enum Message {
    Quit, // 无数据变体, 传统枚举常量
    Move {x: i32, y: i32}, // 结构风格变体， 结构变体携带命名字段的结构化数据
    Write(String), // 单个数据变体
    ChangeColor(u8, u8, u8), // 元组风格变体携带一个或多个有序数据
}

let msg = Message::Move{x: 10, y: 20};

// 模式匹配
fn process_message(msg: Message) {

    match msg {
        Message::Quit => println!("退出"),
        Message::Move{x, y} => println!("move to {}, {}", x, y}),
        Message::Write(text) => pringln!("write {}", text),
        Message::ChangeColor(r, g, b) => pringln!("设置颜色RGB({}, {}, {})", r, g, b)
    }
}

// 定义方法
impl Message {
    fn call(&self) {
    }
}

// 泛型枚举
enum Result<T, E> {
    OK(T),
    Err(E)
}

let ok: Result<i32, &str> = Result::OK(42);
let err: Result<i32, &str> = Result::Err("失败");

Option

Option是一种用于处理值可能缺失的核心枚举类型，强制开发者显示处理所有可能的情况，避免空指针

// 基本定义
pub enum Option<T> {
    Some(T),  //表示存在一个类型为T的值
    None  // 表示空值
}

1. 强制处理缺失值，再可能返回无值的情况下(如HashMap的get方法返回的就是Optin<&T>),调用方法必须处理Some和None两种情况
2. Rust没有空指针，所有潜在空值通过Option显式管理

常见操作

// 模式匹配
let maybe_num = Some(5);
match maybe_num {
    Some(n) => println!("num: {}", n),
    None => println!("none")
}

// unwrap,取Some的值，None时panic
let x = Some(10).unwrap(); // 10
let y = None::<i32>.unwrap(); // 运行时panic!

// expect(msg): 类似unwrap，可以指定panic销售
let z = None::expect("不应该为空") // panic: 不应该为空

// 默认值处理， unwrap_or(default) , None时返回默认值
let num = None.unwrap_or(0); // 0
// 惰性计算默认值,  只有为None或Result::Err时才会执行闭包内的代码
// || {闭包逻辑}
// || 是 Rust 中定义闭包（匿名函数）的语法，用于包裹参数列表。， 带参数闭包​​：|a, b| { ... }， 无参数闭包​​：|| { ... }
// ​​闭包（Closure）​​ 是一种匿名函数，可以捕获其所在环境的变量，并延迟执行逻辑。
let num = None.unwrap_or_else(|| expensive_calculation());

// 链式操作
// map 转换some内部的值
let may_str = Some("hello")
let len = may_str.map(|s| s.len());  // Some(5)

// and_then扁平化链式调用类似flatMap
fn parse(s: &str)-> Option<i32> {}
let result = Some("123").and_then(parse); // Some(123)

// filter 条件过滤
let maybe_even = Some(4).filter(|&n| n % 2 == 0);  // Some(4)
let not_even = Some(5).filter(|&n| n % 2 == 0);  // None

Result

// 定义 
pub enum Result<T, E> {
    Ok(T),  // 成功，携带类型为T的值
    Err(E)  // 失败，携带类型为E的错误信息
}

1. 强制错误处理，任何可能失败的操作必须返回Result<T, E> 调用方法必须处理Ok和Err两种情况
2. 替代异常机制：Rust没有传统异常，所有错误通过Result显示传递
3. 错误信息丰富，可携带任意类型的错误上下文，便于调试和日志记录

Option和Result转换

// ok_or： 将Option转换为Result
let maybe_num = Some(5);
let result: Result<i32, &str> maybe_num.ok_or("无值"); //Ok(5)

// ok_or_else 惰性生成错误
let result = None.ok_or_else(|| "计算失败");