首先，让我们注释类型：
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 循环所做的），或者将 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() 的方法采用self 类型的&Vec<Box<dyn Foo>> (v)？”它首先在Clone impl 上为Vec<Box<dyn Foo>> 寻找这种方法（因为Clone::clone() 需要&self，所以对于Vec<Box<dyn Foo>> 它需要&Vec<Box<dyn Foo>>）。不幸的是，这样的 impl 不存在，所以它具有 autoref 的魔力（尝试在 Rust 中调整方法接收器的过程的一部分，您可以阅读更多 here），并为 &&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一个超级特征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 indeed requires Sized。为什么？
好吧，因为为了克隆一些东西，我们需要返回它自己。我们可以返回dyn Foo 吗？不，因为它可以是任意大小。
所以，让我们手动尝试impl Clone for Box<dyn Foo>（我们可以这样做，即使Box 没有在我们的 crate 中定义，因为它是一个基本类型并且Foo 是本地的（在我们的 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 概括了这个想法。