属于某一特征的对象向量

Question

考虑以下代码：

trait Animal {
    fn make_sound(&self) -> String;
}

struct Cat;
impl Animal for Cat {
    fn make_sound(&self) -> String {
        "meow".to_string()
    }
}

struct Dog;
impl Animal for Dog {
    fn make_sound(&self) -> String {
        "woof".to_string()
    }
}

fn main () {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let v: Vec<Animal> = Vec::new();
    v.push(cat);
    v.push(dog);
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
}

当我尝试推送＜code＞cat＜/code＞时，编译器告诉我＜code＞v＜/code＞是＜code＞动物＜/code＞的向量（类型不匹配）

那么，如何制作一个属于trait的对象向量，并在每个元素上调用相应的trait方法呢？

Answer 1

您可以使用引用特征对象

通过添加Vec来更改的泛型类型

fn main() {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let mut v: Vec<&Animal> = Vec::new();
    //             ~~~~~~~
    v.push(&dog);
    v.push(&cat);
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
    // Ownership is still bound to the original variable.
    println!("{}", cat.make_sound());
}

如果您想保留原始变量的所有权并在以后重用它，这是非常好的。

请记住上面的场景，您不能转让dog或cat的所有权，因为Vec在同一范围内借用了这些具体实例。

引入新作用域有助于处理该特定情况：

fn main() {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    {
        let mut v: Vec<&Animal> = Vec::new();
        v.push(&dog);
        v.push(&cat);
        for animal in v.iter() {
            println!("{}", animal.make_sound());
        }
    }
    let pete_dog: Dog = dog;
    println!("{}", pete_dog.make_sound());
}

Answer 2

<代码>Vec

<anon>:22:9: 22:40 error: instantiating a type parameter with an incompatible type `Animal`, which does not fulfill `Sized` [E0144]
<anon>:22     let mut v: Vec<Animal> = Vec::new();
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

这不合法的原因是Vec

为了解决这个问题，我们需要在Vec中存储具有大小的东西。最直接的解决方案是将值包装在Box中，即Vec

下面是一个工作的< code>main:

fn main() {
    let dog: Dog = Dog;
    let cat: Cat = Cat;
    let mut v: Vec<Box<Animal>> = Vec::new();
    v.push(Box::new(cat));
    v.push(Box::new(dog));
    for animal in v.iter() {
        println!("{}", animal.make_sound());
    }
}