Rust如何定义支持存放多个实现同一trait的不同结构体的Vec

Rust没有面向对象语言的继承机制，不存在用父类指针统一存储子类实例的写法，你的代码无法编译的核心原因有两个：

• 你定义的Object<T>是带泛型参数的trait，Int实现的Object<Int>和Integer实现的Object<Integer>是完全独立的两个trait实现，没有统一的类型标识，无法归入同一个动态类型容器。
• 带泛型参数的trait默认不符合trait对象安全要求：你的sub方法入参和返回值都是泛型类型T，Rust编译器无法在运行时确定泛型的具体大小和类型，因此不能直接用dyn Object构造trait对象。

方案1：使用枚举做静态分发（推荐，无运行时开销） #

如果你明确知道要存入Vec的所有类型，Rust中更推荐用枚举统一包装所有类型，不需要动态分发，性能更高，示例代码如下：

// 保留你原有定义的Object trait、Int、Integer结构体和实现逻辑
#[derive(Debug, Clone)]
enum AnyObject {
    Int(Int),
    Integer(Integer),
}

fn main() {
    let mut v: Vec<AnyObject> = Vec::new();
    v.push(AnyObject::Integer(Integer::new(1)));
    v.push(AnyObject::Int(Int::new(2)));

    // 使用时通过match匹配类型即可调用对应方法
    for item in v {
        match item {
            AnyObject::Int(int) => println!("Int value: {}", int.get()),
            AnyObject::Integer(integer) => println!("Integer value: {}", integer.get()),
        }
    }
}

如果需要统一调用sub方法，可直接给AnyObject枚举实现对应的逻辑，匹配同类型参数做运算即可。

方案2：调整trait设计，构造合法的trait对象做动态分发 #

如果你需要支持后续扩展未知类型，可以修改trait定义，移除泛型参数，把入参和返回值都改成trait对象的包装类型，满足对象安全要求，示例代码如下：

// 重新设计无泛型的Object trait，满足对象安全要求
pub trait Object: Clone + std::fmt::Debug + 'static {
    // 入参和返回值都用trait对象包装，消除泛型
    fn sub(&self, x: &dyn Object) -> Box<dyn Object>;
    fn get(&self) -> i32;
}

// 给Int实现Object
impl Object for Int {
    fn sub(&self, rhs: &dyn Object) -> Box<dyn Object> {
        // 运行时类型转换，确保入参类型匹配
        let rhs = rhs.downcast_ref::<Int>().expect("仅支持同类型相减");
        Box::new(Int {
            val: self.val - rhs.get()
        })
    }
    fn get(&self) -> i32 {
        self.val
    }
}

// 给Integer实现Object
impl Object for Integer {
    fn sub(&self, rhs: &dyn Object) -> Box<dyn Object> {
        let rhs = rhs.downcast_ref::<Integer>().expect("仅支持同类型相减");
        Box::new(Integer {
            val: self.val - rhs.get()
        })
    }
    fn get(&self) -> i32 {
        self.val
    }
}

// 实现类型转换的辅助方法
impl dyn Object {
    pub fn downcast_ref<T: Object>(&self) -> Option<&T> {
        if std::any::Any::type_id(self) == std::any::TypeId::of::<T>() {
            unsafe { Some(&*(self as *const dyn Object as *const T)) }
        } else {
            None
        }
    }
}

// 原有Int、Integer结构体的定义和new方法保持不变
#[derive(Debug, Copy, Clone)]
pub struct Integer {
    val: i32
}
impl Integer {
    pub fn get(&self) -> i32 { self.val }
    pub fn new(val: i32) -> Self { Integer { val } }
}

#[derive(Debug, Copy, Clone)]
pub struct Int {
    val: i32
}
impl Int {
    pub fn get(&self) -> i32 { self.val }
    pub fn new(val: i32) -> Self { Int { val } }
}

fn main() {
    let mut v: Vec<Box<dyn Object>> = Vec::new();
    v.push(Box::new(Integer::new(1)));
    v.push(Box::new(Int::new(2)));
    
    for item in v {
        println!("value: {}", item.get());
    }
}

该方案有少量运行时类型检查开销，但支持后续新增实现Object trait的类型存入Vec，不需要修改现有代码结构。

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