Rust：用 dyn trait 需要注意 object safety 哦

1）Rust 为什么会有 object safety

1.1 dyn Trait 到底是什么

dyn Trait 是类型擦除后的动态派发 ：编译期不关心具体类型是谁，运行时靠 vtable（虚表） 找到对应实现。

一个 &dyn Trait / Box<dyn Trait> 本质上是"胖指针"：

• data pointer：指向真实对象数据
• vtable pointer：指向虚表（里面是一堆函数指针 + 一些元信息）

关键点 ：vtable 里的每个函数入口，必须是"确定的、统一的签名"。因为不管背后是 Foo 还是 Bar，对外都得用同一种方式调用。

1.2 冲突从哪里来

当 trait 方法出现下面情况时，vtable 就没法放一个"统一入口"：

情况 A：方法是泛型的（需要单态化）

trait T {
    fn foo<U>(&self, u: U);
}

泛型方法需要为每个 U 生成一份机器码（单态化）。

但 vtable 只能放一个固定的函数指针：foo 到底要指向哪个 U 的版本？放不下。

情况 B：方法需要知道 Self 的具体大小/布局

比如：

trait T {
    fn clone(&self) -> Self;  // 返回 Self
    fn take(self);            // 按值拿走 self
    fn merge(&self, other: Self); // 参数是 Self
}

对 dyn T 来说，Self 是"不知道是谁"，大小未知。

返回 Self/按值传 Self 都需要知道具体大小和如何 move/构造，所以做不到。

object safety 就是 Rust 把这些"vtable 做不到的签名"禁止掉。

一句话总结原因：
dyn = 运行时多态（vtable）；vtable 需要固定签名；泛型/裸 Self 会让签名无法固定。

---

2) 如何快速判断一个 trait 是否 object-safe（速查）

只看"能在 dyn Trait 上调用的方法"，满足就行；不满足的可以 where Self: Sized 隔离。

2.1 会导致"不 object-safe"的高频点（你先记这 4 个）

1. 泛型方法 ：fn f<T>(&self, ...)
2. 返回 Self ：fn f(&self) -> Self
3. 参数里出现 Self（非引用） ：fn f(&self, x: Self)
4. 按值 receiver ：fn f(self)（除非用 self: Box<Self> 这种指针 receiver）

你先掌握这四条，已经能覆盖绝大多数实际报错。

2.2 where Self: Sized 是"隔离开关"

trait T {
    fn call(&self); // ✅ 进 vtable，可 dyn 调用

    fn new() -> Self
    where
        Self: Sized; // ✅ 不进 vtable，只能静态调用
}

含义：trait 还能 dyn，但 new() 不能对 dyn T 调。

---

3) 不 object-safe 的 trait：怎么改 API（工程套路 3 选 1）

套路 1：where Self: Sized 隔离（最常见）

适用于：你确实想保留 fn new()->Self、fn clone()->Self 这种"只对具体类型有意义"的能力。

trait Service {
    fn handle(&self, req: Request) -> Response;

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

你在用 trait object 时就只用 handle；构造还是用具体类型 MyService::new()。

---

套路 2：把 Self 改成"对象安全的返回类型"（常见是 Box<dyn Trait>）

适用于：你需要在运行时多态的语境下"返回一个同类对象"。

把 -> Self 改成 -> Box<dyn Trait>：

trait Shape {
    fn area(&self) -> f64;

    fn clone_dyn(&self) -> Box<dyn Shape>;
}

这就是为什么 dyn Clone 不行 ，但"clone 成 Box<dyn Trait>"可以。

---

套路 3：拆 trait（一个给 dyn，一个给静态泛型）

适用于：你既想要 dyn（插件/回调），又想要泛型/返回 Self 的"高级能力"。

trait Plugin {
    fn run(&self);
}

// 静态扩展能力（不用于 dyn）
trait PluginExt: Plugin {
    fn new() -> Self where Self: Sized;
    fn map<T>(&self, x: T) where Self: Sized;
}

Plugin 保证 object-safe，PluginExt 给具体类型用。

---

4) 影响范围：除了"书上 trait object"你会在哪遇到？

只要你在做类型擦除边界，就会遇到 object safety：

1. 插件系统 / 策略模式

Vec<Box<dyn Plugin>>

插件接口必须 object-safe。

2. 中间件 / handler 链

Box<dyn Handler>

为了把不同 handler 放在同一个容器里，用 dyn；接口要 object-safe。

3. 回调（闭包 trait）
   dyn Fn(...) 本质也是 trait object，闭包相关抽象会落到 object safety 的设计上。
4. async trait 设计
   如果你想把异步行为放进 dyn Trait，经常会被迫在：

• 返回 Pin<Box<dyn Future<...>>>（走 dyn）
  vs
• impl Future/GAT（走静态）
  之间取舍。背后也是"返回类型能否在 vtable 下固定"。

所以：

object safety 是 Rust 为了让 trait 能用 dyn Trait 做类型擦除和 vtable 动态派发设置的限制。因为 vtable 需要固定的函数签名，所以 trait 里如果有泛型方法（需要单态化）或方法签名依赖具体 Self（比如返回 Self/按值传 Self/self by value）就不能做成 trait object。工程上通常用 where Self: Sized 把这类方法隔离，或把返回值改成 Box<dyn Trait>，必要时拆成 object-safe 的核心 trait + 仅供静态的扩展 trait。常见于插件、handler、中间件、回调、async trait 这些类型擦除边界.from Pomelo_刘金，转载请注明原文链接。感谢！。