如何在 Rust 中定义 Vec 以支持包含实现相同特征的多种类型的结构？

Question

In c++, I can define a parent class, and the type in vector can just be the father class type. So how to implement that in Rust?

Like for this example:

I defined two types of Integer who both implement the trait Object, now I want to put them in a same vector, is there any way to achieve that?

pub trait Object<T: Object<T>+Clone> {
    fn sub(&self, x: &T) -> T {
        x.clone() //this is a useless implementation, just for structs don't need to implement this method.
    }
}

#[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
        }
    }
}

impl Object<Int> for Int {
    fn sub(&self, rhs: &Int) -> Int {
        Int {
            val: self.val - rhs.get()
        }
    }
}


impl Object<Integer> for Integer {
    fn sub(&self, rhs: &Integer) -> Integer {
        Integer {
            val: self.val - rhs.get()
        }
    }
}

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

Thanks a lot.

Answer 1

There are several aspects of your design that don't fit in Rust:

• trait Object<T: Object<T>+Clone> doesn't help - Rust doesn't do CRTP , just use Self instead.
• for Object to be object-safe (necessary to put it in a vector), it can't be parameterized by type. A type parameter means you get a completely separate trait for each type.
• for the same reason, Object::sub() it can't return values by value - it should return Box<dyn Object> instead.

The code modified as indicated looks like this:

pub trait Object {
    fn get(&self) -> i32;
    fn sub(&self, x: &dyn Object) -> Box<dyn Object>;
}

#[derive(Debug, Copy, Clone)]
pub struct Integer {
    val: i32,
}

impl Integer {
    fn new(val: i32) -> Box<dyn Object> {
        Box::new(Int {val})
    }
}

impl Object for Integer {
    fn get(&self) -> i32 {
        self.val
    }

    fn sub(&self, rhs: &dyn Object) -> Box<dyn Object> {
        Integer::new(self.val - rhs.get())
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Int {
    val: i32,
}

impl Int {
    fn new(val: i32) -> Box<dyn Object> {
        Box::new(Int {val})
    }
}

impl Object for Int {
    fn get(&self) -> i32 {
        self.val
    }

    fn sub(&self, rhs: &dyn Object) -> Box<dyn Object> {
        Int::new(self.val - rhs.get())
    }
}

fn main() {
    let mut v: Vec<Box<dyn Object>> = Vec::new();
    v.push(Integer::new(1));
    v.push(Integer::new(2));
    v.push(v[0].sub(v[1].as_ref()));
    for o in &v {
        println!("{}", o.get());
    }
}

Playground

Answer 2

I think you can combine trait and provide a blank implementation, then use that in vector

trait traitA {}
trait traitB {}
trait CombinedTraitATraitB: TraitA + TraitB {}
impl<T> CombinedTraitATraitB for T where T: TraitA + TraitB  {}

let vector: Vec<Box<dyn CombinedTraitATraitB>> = vec![];