Rust中同时使用trait向量元素与自身类型的零开销惯用方案

针对Clock组件既要作为Widget统一管理、又要调用独有方法的问题，以下是几种无需unsafe代码的零开销方案：

方案1：单独管理Clock实例 #

将Clock从通用Widget向量中剥离，单独维护实例，主循环里分别处理更新、渲染逻辑。这种方式完全安全，无额外运行开销。

trait Widget {
    fn update_info(&mut self);
    fn render(&self);
}

struct NetworkStatus{}
impl Widget for NetworkStatus {
    fn update_info(&mut self) {
        // 查询系统网络信息
    }
    fn render(&self) {
        println!("Connected wirelessly");
    }
}

struct Clock{}
impl Widget for Clock {
    fn update_info(&mut self) {
        // 查询系统当前时间
    }
    fn render(&self) {
        println!("2024-03-06T19:25:17");
    }
}
impl Clock {
    fn get_alignment_delay(&mut self) -> std::time::Duration {
        std::time::Duration::new(1, 0)
    }
}

fn main() {
    let mut netstat = NetworkStatus{};
    let mut clock = Clock{};
    let mut widgets: Vec<&mut dyn Widget> = vec![&mut netstat];

    loop {
        // 更新通用Widget
        for w in widgets.iter_mut() {
            w.update_info();
        }
        // 单独更新Clock
        clock.update_info();

        // 渲染通用Widget
        for w in widgets.iter() {
            w.render();
        }
        // 单独渲染Clock
        clock.render();

        // 直接调用Clock独有方法
        std::thread::sleep(clock.get_alignment_delay());
    }
}

优点：逻辑直观，完全安全，无任何额外开销；缺点：若后续新增多个特殊Widget，代码会变得零散。

方案2：用枚举封装所有Widget类型 #

创建枚举类型覆盖所有Widget实现，通过枚举匹配处理特殊逻辑。这种方式是静态分发，零运行开销，且能统一管理所有组件。

trait Widget {
    fn update_info(&mut self);
    fn render(&self);
}

struct NetworkStatus{}
impl Widget for NetworkStatus {
    fn update_info(&mut self) {
        // 查询系统网络信息
    }
    fn render(&self) {
        println!("Connected wirelessly");
    }
}

struct Clock{}
impl Widget for Clock {
    fn update_info(&mut self) {
        // 查询系统当前时间
    }
    fn render(&self) {
        println!("2024-03-06T19:25:17");
    }
}
impl Clock {
    fn get_alignment_delay(&mut self) -> std::time::Duration {
        std::time::Duration::new(1, 0)
    }
}

// 枚举封装所有Widget类型
enum StatusWidget {
    Network(NetworkStatus),
    Clock(Clock),
}

// 为枚举实现Widget trait
impl Widget for StatusWidget {
    fn update_info(&mut self) {
        match self {
            StatusWidget::Network(n) => n.update_info(),
            StatusWidget::Clock(c) => c.update_info(),
        }
    }

    fn render(&self) {
        match self {
            StatusWidget::Network(n) => n.render(),
            StatusWidget::Clock(c) => c.render(),
        }
    }
}

impl StatusWidget {
    // 仅当为Clock类型时返回延迟值
    fn get_clock_delay(&mut self) -> Option<std::time::Duration> {
        match self {
            StatusWidget::Clock(c) => Some(c.get_alignment_delay()),
            _ => None,
        }
    }
}

fn main() {
    let mut widgets: Vec<StatusWidget> = vec![
        StatusWidget::Network(NetworkStatus{}),
        StatusWidget::Clock(Clock{}),
    ];

    loop {
        // 更新所有组件
        for w in widgets.iter_mut() {
            w.update_info();
        }

        // 渲染所有组件
        for w in widgets.iter() {
            w.render();
        }

        // 获取Clock的延迟（假设仅一个Clock）
        let delay = widgets.iter_mut()
            .find_map(|w| w.get_clock_delay())
            .unwrap_or(std::time::Duration::new(1, 0));
        
        std::thread::sleep(delay);
    }
}

优点：统一管理所有组件，静态分发无运行时开销，安全可控；缺点：新增Widget类型时需修改枚举定义，扩展性稍弱，但适合状态栏这类组件数量固定的场景。

方案3：利用Any trait向下转型 #

为Widget trait添加Any作为超 trait，实现安全的向下转型，从而调用Clock的独有方法。这种方式是动态分发，仅存在极轻微的类型检查开销，适合组件类型不确定的场景。

use std::any::Any;

// 让Widget继承Any trait
trait Widget: Any {
    fn update_info(&mut self);
    fn render(&self);

    // 辅助方法用于向下转型
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

// 为所有实现Widget的类型默认实现as_any方法
impl<T: Any + Widget> Widget for T {
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

struct NetworkStatus{}
impl Widget for NetworkStatus {
    fn update_info(&mut self) {
        // 查询系统网络信息
    }
    fn render(&self) {
        println!("Connected wirelessly");
    }
}

struct Clock{}
impl Widget for Clock {
    fn update_info(&mut self) {
        // 查询系统当前时间
    }
    fn render(&self) {
        println!("2024-03-06T19:25:17");
    }
}
impl Clock {
    fn get_alignment_delay(&mut self) -> std::time::Duration {
        std::time::Duration::new(1, 0)
    }
}

fn main() {
    let mut netstat = NetworkStatus{};
    let mut clock = Clock{};
    let mut widgets: Vec<&mut dyn Widget> = vec![&mut netstat, &mut clock];

    loop {
        for w in widgets.iter_mut() {
            w.update_info();
        }

        for w in widgets.iter() {
            w.render();
        }

        // 安全向下转型到Clock
        let delay = widgets.iter_mut()
            .find_map(|w| w.as_any_mut().downcast_mut::<Clock>())
            .map(|c| c.get_alignment_delay())
            .unwrap_or(std::time::Duration::new(1, 0));
        
        std::thread::sleep(delay);
    }
}

优点：无需修改现有Widget管理方式，扩展性好；缺点：存在轻微动态类型检查开销，但对于状态栏场景可忽略不计。

内容的提问来源于stack exchange，提问作者rockerbacon