创建盒装特征背后的机制如何运作？

Question

我无法理解盒装特征的值是如何产生的。考虑以下代码：

trait Fooer {
    fn foo(&self);
}

impl Fooer for i32 {
    fn foo(&self) { println!("Fooer on i32!"); }
}

fn main() {
    let a = Box::new(32);                        // works, creates a Box<i32>
    let b = Box::<i32>::new(32);                 // works, creates a Box<i32>
    let c = Box::<dyn Fooer>::new(32);           // doesn't work
    let d: Box<dyn Fooer> = Box::new(32);        // works, creates a Box<Fooer>
    let e: Box<dyn Fooer> = Box::<i32>::new(32); // works, creates a Box<Fooer>
}

显然，变体 a 和 b 可以正常工作。但是，变体 c 没有，可能是因为 new 函数只接受相同类型的值，而自 Fooer != i32 以来情况并非如此。变体 d 和 e 工作，这让我怀疑正在执行某种从 Box<i32> 到 Box<dyn Fooer> 的自动转换。

所以我的问题是：

• 这里是否发生了某种转换？
• 如果是这样，它背后的机制是什么，它是如何工作的？ （我也对底层细节感兴趣，即在幕后如何表示东西）
• 有没有办法直接从i32 创建Box<dyn Fooer>？如果没有：为什么不呢？

Answer 1

我将尝试解释您的代码中发生了哪些转换（强制）。

有一个名为 Unsize 的标记特征，除其他外：

Unsize 用于：

• 当T: Trait 时T 是Unsize<Trait>。
• [...]

这个特性，AFAIK，不直接用于强制。而是使用CoerceUnsized。这个特性在很多情况下都会实现，其中一些是相当预期的，例如：

impl<'a, 'b, T, U> CoerceUnsized<&'a U> for &'b T 
where
    'b: 'a,
    T: Unsize<U> + ?Sized,
    U: ?Sized

用于将&i32 强制转换为&Fooer。

影响您的代码的这个特征的有趣但不那么明显的实现是：

impl<T, U> CoerceUnsized<Box<U>> for Box<T> 
where
    T: Unsize<U> + ?Sized,
    U: ?Sized

这与Unsize 标记的定义一起可以理解为：如果U 是一个特征并且T 实现U，那么Box<T> 可以强制转换为@ 987654337@.

关于你的最后一个问题：

有没有办法直接从i32 创建Box<Fooer>？如果没有：为什么不呢？

我不知道。问题是Box::new(T) 需要一个有大小的值，因为传递的值被移动到盒子里，而没有大小的值不能被移动。

在我看来，最简单的方法就是简单地写：

let c = Box::new(42) as Box<Fooer>;

也就是说，您创建一个正确类型的 Box，然后强制转换为未调整大小的那个（注意它看起来与您的 d 示例非常相似）。

Answer 2

但是，变体 c 没有，可能是因为 new 函数只接受相同类型的值，而自 Fooer != i32 以来情况并非如此。

不，这是因为Box<dyn Fooer> 没有new 函数。在documentation：

impl<T> Box<T>

pub fn new(x: T) -> Box<T>

Box<T> 上的大多数方法都允许T: ?Sized，但new 是在impl 中定义的没有T: ?Sized 绑定。 means 只能在 T 是已知大小的类型时调用 Box::<T>::new。 dyn Fooer 没有大小，所以根本没有要调用的 new 函数。

事实上，这个函数不能存在于今天的 Rust 中。 Box<T>::new 需要知道具体类型 T 以便它可以分配正确大小和对齐的内存。因此，您不能删除T之前您将其发送到Box::new。 （可以想象，future language extensions 可能允许函数接受未调整大小的参数；但是，即使是 unsized_locals 是否真的会让Box<T>::new 接受未调整大小的T，也不清楚。）

目前，像dyn Fooer这样的unsized类型只能存在于一个“胖指针”后面，即一个指向对象的指针和一个指向Fooer的实现的指针那个物体。你如何得到一个胖指针？你从一个细指针开始并强制它。这就是这两行发生的事情：

let d: Box<Fooer> = Box::new(32);        // works, creates a Box<Fooer>
let e: Box<Fooer> = Box::<i32>::new(32); // works, creates a Box<Fooer>

Box::new 返回一个Box<i32>，然后是coerced 到Box<Fooer>。您可以认为这是一种转换，但 Box 没有改变；编译器所做的只是在它上面加上一个额外的指针并忘记它的原始类型。 rodrigo's answer 更详细地介绍了这种强制转换的语言级机制。

希望所有这些都可以解释为什么答案

有没有办法直接从i32 创建Box<Fooer>？

是“否”：i32 必须被装箱在你可以删除它的类型。这也是你不能写let x: Fooer = 10i32的原因。

相关

• Why can't I write a function with the same type as Box::new?
• Are polymorphic variables allowed?
• How do you actually use dynamically sized types in Rust?
• Why is `let ref a: Trait = Struct` forbidden?