Question

对不起，如果这看起来微不足道，但我正在尝试做一个简单的操作，但我很难这样做。我只想拥有两个特征对象，其中一个具有一个包含另一个对象的Vector。

trait MetaClass {
    fn new() -> Self;
    fn add(&self, subtrait: Box<SubClass>);
}

struct MetaStruct {
    elems: Vec<Box<SubClass>>,
}

impl MetaClass for MetaStruct{
    fn new() -> MetaStruct {
        MetaStruct{
            elems: Vec::new(),
        }
    }

    fn add(&self, subtrait: Box<SubClass>){
        // if I reformulate the above to 'fn add(&self, subtrait: SubClass){'
        // and use the below I get the trait `core::marker::Sized` is not implemented for the type `SubClass`
        //self.elems.push(Box::new(subtrait));
        self.elems.push(subtrait);
    }
}


trait SubClass{
    fn new() -> Self;
}

struct MySubClass {
    data: i32,
}

impl SubClass for MySubClass {
    fn new() -> MySubClass{
        MySubClass{
            data: 10,
        }
    }
}


fn main(){
    let mut meta = Box::new(MetaStruct::new());
    // ideally I just want to do meta.add(MySubClass::new()) but as mentioned above that has some sizing issues :'(
    meta.add(Box::new(MySubClass::new()));
}

我得到的错误是：

<anon>:45:11: 45:38 error: cannot convert to a trait object because trait `SubClass` is not object-safe [E0038]
<anon>:45   meta.add(Box::new(MySubClass::new()));
                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~

以下是生锈玩法的链接：http://is.gd/pjLheJ

我也尝试了以下内容，但得到了同样的错误：

meta.add(Box::new(MySubClass::new()) as Box<SubClass>);

理想情况下，如果有一种方法可以使用Rust的静态调度来实现这一点，那将是理想的，但我也可以使用动态调度。在每种情况下，我认为让MetaClass实际拥有子类的对象是有意义的，所以我不想传递对它的引用，而是整个对象本身。

Answer 1

我只想拥有两个特征对象，其中一个具有一个包含另一个对象的Vector。

这很直接：

trait TraitOne {
    fn add(&mut self, another: Box<TraitTwo>);
}

trait TraitTwo {
    fn value(&self) -> u8; 
}

struct Container(Vec<Box<TraitTwo>>);
impl TraitOne for Container {
    fn add(&mut self, another: Box<TraitTwo>) {
        self.0.push(another);
    }
}

struct ThingOne(u8);
impl TraitTwo for ThingOne {
    fn value(&self) -> u8 { self.0 }
}

struct ThingTwo(u8, u8);
impl TraitTwo for ThingTwo {
    fn value(&self) -> u8 { self.0 + self.1 }
}

fn main() {
    let mut trait_1: Box<TraitOne> = Box::new(Container(vec![]));

    let thing_1: Box<TraitTwo> = Box::new(ThingOne(42));
    let thing_2: Box<TraitTwo> = Box::new(ThingTwo(21, 21));

    trait_1.add(thing_1);
    trait_1.add(thing_2);
}

您的真正错误是关于对象安全。 Huon Wilson（Rust核心团队成员）写了great blog post about this。

在你的情况下，你有这个特点：

trait SubClass{
    fn new() -> Self;
}

这不是对象安全，引用Huon（强调我的）：

有两种基本方式可以发生这种情况，作为参数或返回值，在任何一种情况下，对Self类型的引用意味着它必须匹配self值的类型， true类型这在编译时是未知的。

也就是说，需要在堆栈或堆上分配多少字节来保存fn new() -> Self返回的对象？你无法知道，因为你只有一个特质对象。

根据followup blog post，一个解决方案是确保Self在您的特质中Sized：

trait SubClass {
    fn new() -> Self where Self: Sized;
}

然后，只需修复特征中的一些可变性不匹配，然后进行编译。

在基础特征对象中包含特征对象

1 个答案: