Rust中如何创建存储含PartialEq父特征的特征对象的Vector？

我想要创建一个vector，用于存储实现某一trait的不同结构体对象，但希望该trait是Eq（进而也是PartialEq）的父特征。

《Rust程序设计语言》里提到用Vec<Box<dyn Draw>>的实现方式，但因为PartialEq的依赖，这种写法会触发「特征无法被对象化」错误。有一个针对HashMap的类似实现方案，但对我的需求来说太冗长了。

那创建存储此类特征实现结构体的vector的惯用方法是什么？

可复现代码如下：

pub trait MyTrait: PartialEq { fn my_func() -> bool; }

pub struct Struct1 { age: i32 }

impl PartialEq<Self> for Struct1 {
    fn eq(&self, other: &Self) -> bool { self.age == other.age }
}

impl MyTrait for Struct1 {
    fn my_func() -> bool { false }
}
pub struct Struct2 { year: i32 }

impl PartialEq<Self> for Struct2 {
    fn eq(&self, other: &Self) -> bool { self.year == other.year }
}

impl MyTrait for Struct2 {
    fn my_func() -> bool { true }
}

fn main() {
    let mut v: Vec<Box<dyn MyTrait>> = Vec::new();
    // v.push(Struct1 { age: 1 });
    // v.push(Struct2 { year: 2 });
}

出现错误的核心原因是**PartialEq不是对象安全的**。PartialEq的eq方法签名是fn eq(&self, other: &Self) -> bool，这里的Self要求是具体类型，但dyn MyTrait作为 trait 对象擦除了具体类型信息，没法在运行时确保other和self是同一种类型，也就没法调用对应类型的eq实现。

针对这个需求，有两种惯用处理方式：

方式一：在自定义 trait 中添加动态比较方法 #

放弃让MyTrait直接继承PartialEq，而是在 trait 内定义支持动态类型比较的方法，同时为每个实现类型手动处理类型检查和比较逻辑：

pub trait MyTrait {
    fn my_func(&self) -> bool; // 改成带&self的方法，静态方法不适合trait对象
    fn eq_dyn(&self, other: &dyn MyTrait) -> bool;
    fn as_any(&self) -> &dyn std::any::Any; // 用于运行时类型检查
}

// 为所有实现MyTrait的类型自动实现as_any方法
impl<T: MyTrait + 'static> MyTrait for T {
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

pub struct Struct1 { age: i32 }

impl PartialEq for Struct1 {
    fn eq(&self, other: &Self) -> bool { self.age == other.age }
}

impl MyTrait for Struct1 {
    fn my_func(&self) -> bool { false }
    fn eq_dyn(&self, other: &dyn MyTrait) -> bool {
        // 先检查类型是否匹配，匹配再比较
        other.as_any().downcast_ref::<Self>().map_or(false, |o| self == o)
    }
}

pub struct Struct2 { year: i32 }

impl PartialEq for Struct2 {
    fn eq(&self, other: &Self) -> bool { self.year == other.year }
}

impl MyTrait for Struct2 {
    fn my_func(&self) -> bool { true }
    fn eq_dyn(&self, other: &dyn MyTrait) -> bool {
        other.as_any().downcast_ref::<Self>().map_or(false, |o| self == o)
    }
}

fn main() {
    let mut v: Vec<Box<dyn MyTrait>> = Vec::new();
    v.push(Box::new(Struct1 { age: 1 }));
    v.push(Box::new(Struct2 { year: 2 }));

    // 测试比较逻辑
    println!("{}", v[0].eq_dyn(&*v[0])); // 输出 true
    println!("{}", v[0].eq_dyn(&*v[1])); // 输出 false
}

这里借助std::any::Any做运行时类型检查，只有当两个对象是同一种具体类型时才执行比较，否则直接返回false。同时注意把原有的my_func改成带&self的方法——静态方法无法通过 trait 对象调用，因为 trait 对象没有具体类型信息。

方式二：用枚举封装所有可能的类型 #

如果你的结构体类型是有限且已知的，用枚举统一封装是更简洁高效的方案，完全不需要 trait 对象：

pub trait MyTrait: PartialEq {
    fn my_func(&self) -> bool;
}

pub struct Struct1 { age: i32 }

impl PartialEq for Struct1 {
    fn eq(&self, other: &Self) -> bool { self.age == other.age }
}

impl MyTrait for Struct1 {
    fn my_func(&self) -> bool { false }
}

pub struct Struct2 { year: i32 }

impl PartialEq for Struct2 {
    fn eq(&self, other: &Self) -> bool { self.year == other.year }
}

impl MyTrait for Struct2 {
    fn my_func(&self) -> bool { true }
}

// 枚举封装所有实现MyTrait的类型
#[derive(PartialEq)]
enum MyEnum {
    Struct1(Struct1),
    Struct2(Struct2),
}

// 为枚举实现MyTrait
impl MyTrait for MyEnum {
    fn my_func(&self) -> bool {
        match self {
            MyEnum::Struct1(s) => s.my_func(),
            MyEnum::Struct2(s) => s.my_func(),
        }
    }
}

fn main() {
    let mut v: Vec<MyEnum> = Vec::new();
    v.push(MyEnum::Struct1(Struct1 { age: 1 }));
    v.push(MyEnum::Struct2(Struct2 { year: 2 }));

    // 测试比较逻辑
    println!("{}", v[0] == v[0]); // 输出 true
    println!("{}", v[0] == v[1]); // 输出 false
}

这种方案的优势是类型安全、性能更高（没有动态分发的开销），而且天然支持PartialEq和Eq（只要枚举的每个变体都实现了对应的 trait）。后续需要添加新类型时，只需要扩展枚举变体即可。

选择建议 #

• 如果你的类型集合固定且有限，优先用枚举方案，代码更简洁高效。
• 如果需要支持动态扩展类型（比如允许外部 crate 添加新的实现），则选择 trait 对象+动态比较的方案。

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