Rust中的Enum与Struct示例详解

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);
}

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(); }
}

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

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

// 定义状态
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 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"

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> {
    Some(T),  // 有值：存储类型为T的值
    None,     // 无值
}

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

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