如何克隆 Vec <Box<dyn Trait> &gt;?

Question

我想实现一个函数，它接受一个不可变的&Vec引用，制作一个副本，对值进行排序并打印它们。

这是主要代码。

trait Foo {
    fn value(&self) -> i32;
}

struct Bar {
    x: i32,
}

impl Foo for Bar {
    fn value(&self) -> i32 {
        self.x
    }
}

fn main() {
    let mut a: Vec<Box<dyn Foo>> = Vec::new();
    a.push(Box::new(Bar { x: 3 }));
    a.push(Box::new(Bar { x: 5 }));
    a.push(Box::new(Bar { x: 4 }));

    let b = &a;
    sort_and_print(&b);
}

我能够使它工作的唯一方法是这个

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy = Vec::new();
    for val in v {
        v_copy.push(val);
    }
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

但是我想了解这里发生了什么，并使代码更短。

问题 1

如果我尝试更改let mut v_copy = Vec::new(); let mut v_copy: Vec<Box<dyn Foo>> = Vec::new(); 但是这会导致我不知道如何修复的各种错误。

我如何使这个版本工作，为什么它与第一个版本不同？

尝试 2

更接近我正在寻找的东西是这样的。 let mut v_copy = v.clone(); 但这不起作用。 这个版本可以修复吗？

Answer 1

首先，让我们注释类型：

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy: Vec<&Box<dyn Foo>> = Vec::new();
    for val /* : &Box<dyn Foo> */ in v {
        v_copy.push(val);
    }
    v_copy.sort_by_key(|o: &&Box<dyn Foo>| <dyn Foo>::value(&***o));
    for val /* : &Box<dyn Foo> */ in v_copy {
        println!("{}", <dyn Foo>::value(&**val));
    }
}

迭代&Vec<T>产生一个迭代器&T （与.iter()方法相同。

现在我们可以看到我们可以将它转换为迭代器，通过在v上调用.into_iter()然后.collect() （这是for循环所做的），或者用iter()替换into_iter() iter() （这更惯用因为我们正在迭代引用：

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy: Vec<&Box<dyn Foo>> = v.iter().collect(); // You can omit the `&Box<dyn Foo>` and replace it with `_`, I put it here for clarity.
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

但是，我们仍然只有引用的副本（ &Box<dyn Foo> ）。 为什么我们不能克隆载体？

如果我们尝试...

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy = v.clone();
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

...编译器对我们大喊：

warning: variable does not need to be mutable
  --> src/main.rs:45:9
   |
45 |     let mut v_copy = v.clone();
   |         ----^^^^^^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

error[E0596]: cannot borrow `*v_copy` as mutable, as it is behind a `&` reference
  --> src/main.rs:46:5
   |
45 |     let mut v_copy = v.clone();
   |         ---------- help: consider changing this to be a mutable reference: `&mut Vec<Box<dyn Foo>>`
46 |     v_copy.sort_by_key(|o| o.value());
   |     ^^^^^^ `v_copy` is a `&` reference, so the data it refers to cannot be borrowed as mutable

什么？？？？？？？？？？？

好吧，让我们尝试指定类型。 它可以使编译器更智能。

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy: Vec<Box<dyn Foo>> = v.clone();
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

不。

error[E0308]: mismatched types
  --> src/main.rs:45:41
   |
45 |     let mut v_copy: Vec<Box<dyn Foo>> = v.clone();
   |                     -----------------   ^^^^^^^^^
   |                     |                   |
   |                     |                   expected struct `Vec`, found reference
   |                     |                   help: try using a conversion method: `v.to_vec()`
   |                     expected due to this
   |
   = note: expected struct `Vec<Box<dyn Foo>>`
           found reference `&Vec<Box<dyn Foo>>`

好吧，让我们使用编译器的建议：

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy: Vec<Box<dyn Foo>> = v.to_vec();
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

咕噜！！

error[E0277]: the trait bound `dyn Foo: Clone` is not satisfied
  --> src/main.rs:45:43
   |
45 |     let mut v_copy: Vec<Box<dyn Foo>> = v.to_vec();
   |                                           ^^^^^^ the trait `Clone` is not implemented for `dyn Foo`
   |
   = note: required because of the requirements on the impl of `Clone` for `Box<dyn Foo>`

至少我们现在有了一些线索。

这里发生了什么？

好吧，就像编译器说的那样， dyn Foo没有实现Clone特性。 这意味着Box<dyn Foo>和Vec<Box<dyn Foo>>也不行。

然而， &Vec<Box<dyn Foo>>实际上确实impl Clone 。 这是因为您可以拥有任意数量的共享引用 - 共享（非可变）引用是Copy ，每个Copy也是Clone 。 尝试一下：

fn main() {
    let i: i32 = 123;
    let r0: &i32 = &i;
    let r1: &i32 = <&i32 as Clone>::clone(&r0);
}

因此，当我们编写v.clone() ，编译器会询问“是否有一个名为clone()的方法接受&Vec<Box<dyn Foo>> ( v ) 类型的self ？” 它首先在Clone impl 上为Vec<Box<dyn Foo>>寻找这样的方法（因为Clone::clone()需要&self ，所以对于Vec<Box<dyn Foo>>它需要&Vec<Box<dyn Foo>> )。 不幸的是，这样的 impl 不存在，因此它发挥了 autoref 的魔力（尝试在 Rust 中调整方法接收器的过程的一部分，您可以在此处阅读更多内容），并对&&Vec<Box<dyn Foo>>提出同样的问题&&Vec<Box<dyn Foo>> . 现在我们确实找到了匹配项 - <&Vec<Box<dyn Foo>> as Clone>::clone() ！ 所以这就是编译器调用的。

方法的返回类型是什么？ 好吧， &Vec<Box<dyn Foo>> 。 这将是v_copy的类型。 现在我们明白为什么当我们指定另一种类型时，编译器会发疯！ 当我们没有指定类型时，我们也可以解密错误消息：我们要求编译器在&Vec<Box<dyn Foo>>上调用sort_by_key() ，但是这个方法需要&mut Vec<Box<dyn Foo>> （ &mut [Box<dyn Foo>] ，准确地说，但这并不重要，因为Vec<T>可以强制转换为[T] ）！

我们也可以理解关于冗余mut的警告：我们从不更改引用，因此无需将其声明为可变的！

当我们调用to_vec() ，OTOH 时，编译器并没有感到困惑： to_vec()需要向量的项来实现Clone （ where T: Clone ），而Box<dyn Foo>不会发生这种情况。 繁荣。

现在解决方案应该很清楚了：我们只需要Box<dyn Foo>来实现Clone 。

只是？...

我们可能会想到的第一件事是给Foo一个 supertrait Clone ：

trait Foo: Clone {
    fn value(&self) -> i32;
}

#[derive(Clone)]
struct Bar { /* ... */ }

不工作：

error[E0038]: the trait `Foo` cannot be made into an object
  --> src/main.rs:33:31
   |
33 | fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
   |                               ^^^^^^^ `Foo` cannot be made into an object
   |
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
  --> src/main.rs:1:12
   |
1  | trait Foo: Clone {
   |       ---  ^^^^^ ...because it requires `Self: Sized`
   |       |
   |       this trait cannot be made into an object...

嗯，看起来确实Clone需要Sized 。 为什么？

好吧，因为要克隆某些东西，我们需要返回自身。 我们可以返回dyn Foo吗？ 不，因为它可以是任何大小。

因此，让我们尝试手动impl Clone for Box<dyn Foo> （即使Box未在我们的 crate 中定义，因为它是基本类型，我们也可以这样做）。

impl Clone for Box<dyn Foo> {
    fn clone(self: &Box<dyn Foo>) -> Box<dyn Foo> {
        // Now... What, actually?
    }
}

我们怎么能克隆一些可以成为任何东西的东西呢？ 显然，我们需要将其转发给其他人。 还有谁？ 知道如何克隆这个东西的人。 Foo上的方法？

trait Foo {
    fn value(&self) -> i32;
    fn clone_dyn(&self) -> Box<dyn Foo>;
}

impl Foo for Bar {
    fn value(&self) -> i32 {
        self.x
    }
    
    fn clone_dyn(&self) -> Box<dyn Foo> {
        Box::new(self.clone()) // Forward to the derive(Clone) impl
    }
}

现在！

impl Clone for Box<dyn Foo> {
    fn clone(&self) -> Self {
        self.clone_dyn()
    }
}

有用！！

fn sort_and_print(v: &Vec<Box<dyn Foo>>) {
    let mut v_copy = v.clone();
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=d6e871711146bc3f34d9710211b4a1dd

注意： @dtonlay 的dyn-clone crate 概括了这个想法。

Answer 2

您可以使用Iterator::collect()缩短sort_and_print() Iterator::collect() ：

fn sort_and_print(v: &[Box<dyn Foo>]) {
    let mut v_copy: Vec<_> = v.iter().collect();
    v_copy.sort_by_key(|o| o.value());
    for val in v_copy {
        println!("{}", val.value());
    }
}

操场

顺便说一句，通过引用接受矢量通常更好表示为接受片， 按此处的说明，所以上述答案接受片。

您可以使用itertools箱中的sorted()方法使其更短：

use itertools::Itertools;

fn sort_and_print(v: &[Box<dyn Foo>]) {
    for val in v.iter().sorted_by_key(|o| o.value()) {
        println!("{}", val.value());
    }
}

您几乎肯定不想克隆向量，因为它会涉及深度复制，即克隆每个Box<dyn Foo> ，这是不必要的，可能很昂贵，而且很复杂（如另一个答案中所述）。