想象你去一家连锁奶茶店办了一张“通兑会员卡”，不管走进哪家分店，店员刷一下卡就能按你的会员等级打折扣。卡片能通兑的前提是：总部印制的“服务承诺清单”里，每一项权益都得写得下、兑现得了。如果清单上印着“按你的家乡口味定制饮品”，每家分店就得为无穷多种口味准备做法；如果印着“送你本店专属纪念章”，可通兑卡根本不知道你进的是哪家分店；如果印着“教你加盟开店”，这明明是总店专属服务，分店刷卡系统根本无从发起。清单写不下、兑不了，这张卡就只能作废重印。 在 Rust 里，这张“通兑卡”就是 trait 对象（dyn Trait），而“服务承诺清单”则是编译器要生成的 vtable 虚表。“对象安全（Object Safety）”规则决定了 trait 能不能做成 trait 对象。规则划出了三个禁区：泛型方法、返回 Self、关联函数。本文就用奶茶店的故事，把这三个禁区以及背后的设计思想一次讲透。

岗位关联

掌握对象安全规则，你才能判断何时能用 dyn 做运行时多态，设计出可插拔的抽象接口——这是 Rust 插件架构、错误处理和大型工程设计的核心能力，也是从“会写 Rust”迈向“会设计 Rust”的必经关卡。

目录
  1. 可视化演示
  2. 概念基石：动态分发的底座
  3. 禁区一：方法上的泛型参数
  4. 禁区二：返回Self
  5. 禁区三：关联函数
  6. 判定与豁免：Sized开绿灯
  7. 实战应用：dyn的多态工程
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示dyn Trait的vtable动态分发、三个对象安全禁区和绕过方案。

本节配有交互动效（进入视口后自动加载，约 3KB）。

dyn Trait与Vtable分发 dyn Trait = 数据指针 + vtable指针 运行时通过vtable查找实际impl方法 dyn Trait = (*data, *vtable) 类型擦除后的动态分发

概念基石：动态分发的底座

连锁奶茶店的会员卡要全国通兑，背后必须有一套“总部结算系统”：店员刷卡后，先看卡上记录的“分店类型标签”，再对照总部下发的“服务清单”找到对应的折扣算法。这套系统要稳定运转，前提是服务清单每一行都写得下、写得清。对象安全规则，就是给“写得下、写得清”划出的红线。

在 Rust 里，trait 定义一组接口契约，具体类型（struct）负责实现。当你想在不关心具体类型的情况下调用同一套接口时，就用 trait 对象 dyn Trait。它把具体类型擦除掉，只保留契约本身。这就是“通兑卡”的意义：不管你是 Dog 还是 Cat，只要实现了 Speak 这个 trait，都能被当作 dyn Speak 来调用。

dyn Trait 本质上是一个胖指针：一个指针指向堆上的真实数据，另一个指针指向该类型的 vtable 虚表。方法调用时，先从虚表里查出函数地址再跳转，这就是动态分发；与之相对，泛型在编译期为每个类型生成专用代码，叫静态分发。而对象安全，就是判断“虚表能不能完整建成”的那套体检标准。

回到奶茶店：会员卡背面的“服务清单”必须印得下所有承诺。印不下的承诺，品控总监（编译器）就会把整张卡打回重印。对象安全，就是这张卡能否发行的“质检标准”。

dyn T=(data_ptr, vtable_ptr)\text{dyn } T = (\text{data\_ptr},\ \text{vtable\_ptr})
一个 trait 对象其实是“二合一指针”：左边指向真实数据，右边指向一张方法表。这张表能不能建完整，决定了对象安全与否。
  1. dyn T 是胖指针它由两个普通地址拼成，而不是直接存放对象本体，因此额外携带了“类型身份信息”。
    dyn T=(ptr, vtable_ptr)⏟胖指针\text{dyn } T = \underbrace{(\text{ptr},\ \text{vtable\_ptr})}_{\text{胖指针}}
  2. data_ptr 指向堆上实例具体对象（比如 Dog 结构体）的所有字段都存放在这个地址开始的内存里。
    data_ptr: &Dog\text{data\_ptr}: \ \&\text{Dog}
  3. vtable_ptr 指向虚表虚表按固定顺序存放该类型对 trait 中每个方法的实现地址，相当于奶茶店的“服务清单”。
    vtable_ptr→[ speak_Dog, name_Dog, … ]\text{vtable\_ptr} \to [\ \text{speak\_Dog},\ \text{name\_Dog},\ \dots\ ]
  4. 方法调用变为查表跳转调用 speak() 时，先从虚表取出该方法的函数指针，再做一次间接调用。
    method(x):=vtable[idx](x)\text{method}(x) := \text{vtable}[\text{idx}](x)

禁区一：方法上的泛型参数

假设会员卡上印着“每位顾客都可享受家乡口味定制，口味参数你来定”。每家门店都要为无穷多种口味准备做法，总部的服务清单没法预印所有行——今天你点“重庆辣”，明天他点“广西酸”，后天还有“火星味”，清单永远写不完。

Rust 中方法级泛型 fn convert<T>(&self) -> T 也是同样的困境。静态分发时，编译器会对每个具体类型实参做一次单态化（monomorphization），把泛型展开成一份份专用代码。如果方法有多个泛型参数，那么版本数量是按乘积增长的：两个参数各有 10 种可能，就要生成 100 份实现。

vtable 虚拟表必须在编译期穷举所有可能被调用的方法版本。泛型参数意味着“未知类型 + 未知数量”的组合，编译器无法为将来才出现的 crate 外新类型预先安排表项，所以这类方法被禁止。注意区分：trait 自身的泛型 trait Foo<T> 是允许的，因为 dyn Foo<i32> 已经把 T 定型；禁区只看“方法声明里的泛型参数”。

定制口味本身没错，错的是想把它写进“通兑承诺书”；泛型方法本身没错，只是不能塞进虚表这张固定尺寸的“服务清单”。想用动态分发，就得把方法级泛型挡在门外。

Nversions=∏i=1n∣Ti∣N_{\text{versions}} = \prod_{i=1}^{n} |T_i|
泛型方法的实现版本数量，等于每个类型参数可能取值数量的乘积。产品越大，编译器越没法在虚表里一一登记。
  1. 泛型方法可实例化为海量版本每个类型实参都会让编译器生成一份展开后的代码。
    convert_String, convert_u64, convert_Vec, …\text{convert\_String},\ \text{convert\_u64},\ \text{convert\_Vec},\ \dots
  2. 多泛型参数按乘积增长n 个类型参数，每个有若干可能取值，组合数是乘法关系。
    N=∣T1∣×∣T2∣×⋯×∣Tn∣N = |T_1| \times |T_2| \times \dots \times |T_n|
  3. vtable 无法预登记无限条目因为新类型可能在外部 crate 中才被定义，虚表只能在编译期列出已知项。
    vtable: 有限表≠无限组合\text{vtable}: \ \text{有限表} \neq \text{无限组合}

禁区二：返回Self

会员卡上写着“游戏闯关成功，送本店专属纪念章”。可通兑卡一出示，店员并不知道你进的是哪家分店——纪念章的尺寸、材质、成本完全未知，总部的仓储系统无法预分配货架。

方法签名 fn clone_me(&self) -> Self 看起来人畜无害，但这里的 Self 指“实现这个 trait 的那个具体类型”。如果 Dog 实现了它，Self 就是 Dog 结构体本身；如果 Cat 实现，Self 就是 Cat。问题在于：动态分发时调用方手里只有 dyn Trait 胖指针，具体类型已经被擦除，编译器根本不知道返回的对象在栈上要占多少字节。

栈上分配需要编译期已知大小。Self 的大小因为类型擦除而未知，所以编译器直接拒绝。但如果把签名改成 fn clone_me(&self) -> Box<Self> 就合法了——Box 是一个固定大小的指针，未知大小的对象被搬到堆上，调用方只搬指针。同理，Rc<Self>、Arc<Self> 也安全，因为它们本身就是“已知大小的壳”。

总店没法在通兑卡上承诺“送你本店纪念章”，但如果承诺“送你一个装着纪念章的密封快递盒”，盒子大小统一，就能写进承诺书。这就是 Box<Self> 的智慧：把不确定的内容装进确定的容器。

fn clone_me(&self)→Self\text{fn clone\_me}(\&self) \to \text{Self}
返回 Self 意味着返回一个“大小未知”的具体类型。动态分发把类型擦掉了，编译器连该留多大栈空间都算不出来。
  1. Self 是具体类型别名在实现 trait 的类型中，Self 会展开为该类型本身。
    Self=Dog  (当实现者为 Dog 时)\text{Self} = \text{Dog} \ \ (\text{当实现者为 Dog 时})
  2. 动态分发时类型身份被擦除调用方只知道 dyn Trait，不知道背后是 Dog 还是 Cat。
    类型信息丢失⇒size 未知\text{类型信息丢失} \Rightarrow \text{size 未知}
  3. 栈上分配需要已知大小返回 Self 要在调用方栈帧预留空间，编译器满足不了这个要求。
    未知 size⇒无法编译\text{未知 size} \Rightarrow \text{无法编译}
  4. Box\<Self\> 绕开限制Box 自身是固定大小的指针，堆上具体对象有多大都不影响。
    Box[Self]=固定大小指针\text{Box}[\text{Self}] = \text{固定大小指针}

禁区三：关联函数

品牌总店有一项服务叫“新店加盟申请”，不需要顾客进店，直接联系总部办理就行。但你拿着通兑卡在任意分店说“我要办加盟”，系统刷不出你具体在哪家店，流程根本无从发起。

关联函数（associated function）是 impl 块中不以 self 开头的函数，最典型的就是 fn new() -> Self。它没有实例，像一个“站在类型旁边”的静态函数。动态分发的前提是：拿到某个类型实例的虚表指针，从而查出该类型的方法实现。关联函数没有 self 参数，系统手里没有任何类型线索，无法回答“该执行哪个实现”。

所以“没有 self 接收者”的方法会让 trait 失去对象安全性。注意：在 trait 里定义 fn new() 本身完全合法，静态分发时也能正常调用 Dog::new()；只是这个 trait 无法再做成 trait 对象了。如果确实需要一个构造器，常见的做法是把 new 放到 impl 块里（不放进 trait），或者给方法加上 where Self: Sized 约束来豁免。

通兑卡是发给“进店的顾客”用的；不进门就能办的总店服务，自然没法在分店刷卡系统里兑现。关联函数本身没有错，错的是想让它混进动态分发的世界。

fn new()→Self\text{fn new}() \to \text{Self}
关联函数没有 self，动态分发时缺少“从实例到虚表”的路径。就像没有顾客进店，分店刷不了任何卡。
  1. 没有 self 接收者方法体内不存在“这个实例”的概念，它更像一个类型级的工具函数。
    new: 无接收者\text{new}: \ \text{无接收者}
  2. 动态分发需要类型线索正常的 trait 方法通过 self 找到虚表，再从虚表找到函数地址。
    self→vtable→fnType\text{self} \to \text{vtable} \to \text{fn}_{Type}
  3. 关联函数找不到线索没有 self 就没有虚表入口，编译器无从决定该用哪个实现。
    无 self⇒无法选择实现\text{无 self} \Rightarrow \text{无法选择实现}
  4. where SelfSized 提供逃生通道：给方法加上该约束后，它只在具体类型上下文中可用，不参与动态分发。
    where Self: Sized⇒静态专用\text{where Self: Sized} \Rightarrow \text{静态专用}

判定与豁免：Sized开绿灯

品控总监也懂得变通：如果某条权益印上“仅限本店，通兑无效”的小字，它就不再污染通兑承诺书，其他权益照样全国通用。Rust 的 where Self: Sized 就是这行小字。

当一个 trait 里的方法带上了 where Self: Sized，编译器在对象安全判定时会直接跳过它：这个方法不被纳入 dyn 的保证范围，你用 dyn Trait 调用它会得到编译错误，但 trait 整体依然对象安全。判定流程就像体检：逐条检查每个方法是否触碰三禁区，带豁免的方法直接盖章“免检”，全部通过才能构造 dyn Trait。

实际开发中，这条豁免最常见的用途就是“既要方便的类型级构造器，又要 trait 对象”：

通兑承诺书上有小字限制的服务照样存在，只是换成了分店专用版。对象安全不要求“每个方法都通用”，只要求“写进通兑卡的部分都兑现得了”——这就是 Sized 豁免存在的意义。

where Self: Sized⇒跳过该方法的对象安全检查\text{where Self: Sized} \Rightarrow \text{跳过该方法的对象安全检查}
这条规则的逻辑是：Sized 表示“大小已知”，说明该方法只在确定具体类型时才可调用，因此它不会破坏虚表的可建性。
  1. Sized 表示大小可确定几乎所有具体类型（Dog、Cat、Vec）都是 Sized。
    Dog:Sized\text{Dog}: \text{Sized}
  2. 带该约束的方法只能静态调用它不承诺对“未知类型”可见，动态分发时不可用。
    仅限 T:Sized 上下文\text{仅限} \ T: \text{Sized} \ \text{上下文}
  3. 检查器跳过该方法它不参与三禁区判定，trait 整体仍可对象安全。
    判定=⋀方法(规则通过∨豁免)\text{判定} = \bigwedge_{\text{方法}} (\text{规则通过} \lor \text{豁免})
  4. 判定结论驱动 dyn 可用性所有方法（或被豁免）都通过，才能写 dyn Trait。
    对象安全  ⟺  dyn Trait 可用\text{对象安全} \iff \text{dyn Trait 可用}
rust4 行
trait Animal {    fn new() -> Self where Self: Sized; // 静态可用，dyn 不可用    fn speak(&self);                    // 动态分发可用}

实战应用：dyn的多态工程

把通兑卡真正用起来：顾客走进任意加盟店都能消费。大型软件里，我们经常需要在“运行时接受任意实现同一接口的组件”，这就是 trait 对象的主场。最经典的就是 Box<dyn Error>：不同错误类型被统一装箱向上传播，调用方只关心“这是个错误”。

插件架构更是 trait 对象的典型舞台：宿主程序定义 Plugin trait，各团队分别实现自己的插件，宿主持有 Vec<Box<dyn Plugin>> 统一调用。新增插件时不需要改动宿主代码，这正是运行时多态最迷人的价值。机器学习推理平台也大量使用这种模式——不同推理后端只需要实现同一个 InferenceBackend 接口。

当然，天下没有免费的午餐：动态分发每次调用都要查一次虚表、做一次间接跳转，编译器还无法内联优化；泛型静态分发更快，但所有类型必须在编译期确定。工程上常用的策略是“泛型收窄、dyn 扩宽”：性能敏感的循环用泛型，需要扩展性的边界用 dyn。内存布局上，Box<dyn T> 是一个胖指针，指向堆上的数据和虚表。

总部的通兑系统上线后，新门店只要签约按规则接入，无需停业改造主服务。这正是 trait 对象在插件架构中最迷人的地方：规则在前，扩展在后。

Box[dyn T]=(ptr, vtable_ptr)⏟胖指针→堆上数据\text{Box}[\text{dyn } T] = \underbrace{(\text{ptr},\ \text{vtable\_ptr})}_{\text{胖指针}} \to \text{堆上数据}
Box 拥有堆上对象，胖指针里附带虚表地址。方法调用走虚表间接跳转，这是动态分发的核心结构。
  1. Box 拥有堆上对象所有权和生命周期由 Box 统一管理，调用方只需搬运胖指针。
    Box→Heap(T)\text{Box} \to \text{Heap}(T)
  2. 胖指针携带虚表地址dyn T 的方法查找从 vtable_ptr 开始。
    vtable_ptr→虚表\text{vtable\_ptr} \to \text{虚表}
  3. 调用通过虚表间接跳转这是动态分发的核心成本点，也是换取运行时扩展性的代价。
    call=vtable[idx](args)\text{call} = \text{vtable}[\text{idx}](\text{args})
  4. 泛型与 dyn 可组合使用比如 Vec<Box<dyn Plugin>> 用容器泛型管理异构对象。
    Vec[Box[dyn Plugin]]\text{Vec}[\text{Box}[\text{dyn Plugin}]]

AI 应用场景

插件式特征提取器

阶段：特征工程 / 数据预处理

解决的问题：机器学习特征提取天然多态——数值归一化、时序加窗、文本 TF-IDF 各有一套逻辑。传统做法用枚举加 match 写死，每次新增特征类型都要改主流程入口，极易产生低质量的“面条代码”。用 trait 对象把“特征提取”抽象成统一接口，主流程只依赖 &dyn FeatureExtractor，新增特征无需重新编译主框架。

具体案例：一个平台定义 FeatureExtractor trait（含 extract(&self, row) -> Vec<f64>），CV 团队把图像增强器实现为 extractor，NLP 团队把文本清洗实现为 extractor。训练主循环持有 Vec<Box<dyn FeatureExtractor>> 顺序执行，不同团队的特性如同不同分店，通兑卡一起刷。

推理引擎多后端调度

阶段：模型推理 / 服务部署

解决的问题：推理服务需要同时支持 ONNX Runtime、TensorRT、PyTorch C++ 等后端。若用泛型直接写死，服务框架会随后端数量爆炸式复制；每次新增后端都要改核心代码。用 trait 对象做“后端通兑卡”后，运行时按配置选择一个后端装入 Box<dyn InferenceBackend>，上游接口完全不变。

具体案例：定义 InferenceBackend trait（load_model、predict），四个推理引擎各自实现。推理服务器读取模型文件名和配置项，在运行时装配后端：let backend: Box<dyn InferenceBackend> = registry.create("tensorrt")?; 后续调用完全多态。

训练日志与实验报告抽象

阶段：模型训练 / 实验管理

解决的问题：多模态训练需要同时把指标输出到控制台、文件、远端可视化面板。if-else 分支每加一个输出目标就膨胀一次。用 trait 对象抽象 Reporter，训练循环只看 &dyn Reporter，换报告方式只改一行初始化代码。

具体案例：定义 Reporter trait（on_epoch_end(&self, metrics)），ConsoleReporter、FileReporter、RemoteReporter 分别实现。训练启动时根据配置创建 Box<dyn Reporter> 注入训练循环，新增“钉钉告警”只需新写一个实现类，主循环一行不改。

Python 演示

python56 行
"""模拟 Rust 对象安全三规则检查器（用于教学演示）""" from dataclasses import dataclass  @dataclassclass MethodSig:    name: str    has_receiver: bool  # 是否有 self 接收者    generic_params: list  # 泛型参数名列表, 空列表表示无泛型    returns_self: bool  # 是否返回裸 Self    where_sized: bool  # 是否有 where Self: Sized 豁免  def check_object_safety(methods):    """遍历方法列表, 返回 (trait是否对象安全, 违规详情)"""    violations = []    for m in methods:        if m.where_sized:            continue  # 带豁免的方法不参与对象安全判定        if m.generic_params:            violations.append(m.name + ": 带泛型参数, 触发泛型方法禁区")        if not m.has_receiver:            violations.append(m.name + ": 无 self 接收者, 触发关联函数禁区")        if m.returns_self:            violations.append(m.name + ": 返回裸 Self, 触发返回 Self 禁区")    return len(violations) == 0, violations  def animal_trait():    """构造示例 trait: 一个带违规方法的动物接口"""    return [        MethodSig("speak", True, [], False, False),        MethodSig("convert", True, ["T"], False, False),        MethodSig("new", False, [], True, False),        MethodSig("clone_box", True, [], False, False),  # 返回 Box<Self>, 合法    ]  def main():    methods = animal_trait()    safe, violations = check_object_safety(methods)    print("原始 trait 对象安全?", safe)    for v in violations:        print("  -", v)     print("--- 修复: 移除 convert 和 new 后 ---")    fixed = [m for m in methods if m.name not in ("convert", "new")]    safe2, violations2 = check_object_safety(fixed)    print("修复后对象安全?", safe2)    for v in violations2:        print("  -", v)  if __name__ == "__main__":    main()
目的：用 Python 模拟 Rust 对象安全检查器，直观展示三个禁区如何让 trait 失去动态分发资格，以及修复后如何恢复。
  1. @dataclass声明数据类，让方法签名一目了然，对应 trait 中一个方法的各种属性。
  2. if m.generic_params:命中禁区一：方法带泛型参数，虚表无法穷举版本。
  3. if not m.has_receiver:命中禁区三：没有 self 接收者，动态分发无法定位实现。
  4. if m.returns_self:命中禁区二：返回裸 Self，编译期大小未知。
  5. if m.where_sized: continueSized 豁免：有 where Self: Sized 的方法直接跳过检查。
  6. MethodSig("clone_box", True, [], False, False)返回 Box<Self> 的方法不算裸 Self，合法通过。
  7. fixed = [m for m in methods if m.name not in ("convert", "new")]剔除违规方法后，trait 恢复对象安全。

常见误区

误区“`trait Foo<T>` 有类型参数，这种 trait 肯定不能做 trait 对象吧？我写 `dyn Foo<String>` 编译器肯定会报错。”

正解trait 级泛型参数在实例化时已经定型，dyn Foo<String> 是“把 T 固定为 String 之后的 trait 对象”，完全合法。真正的禁区是“方法声明自身的泛型”，即 fn bar<U>(&self)。前者像会员卡的类型统一，后者像每次点单都不同的定制口味——一个是固定的卡面信息，一个是无穷的定制需求。

为何常见：把“trait 泛型”和“方法泛型”混为一谈，看到尖括号就紧张，没有仔细分辨泛型出现的位置。

误区“既然不能返回 Self，那返回 `Box<Self>` 里面不还是 Self 吗？肯定也不行，应该一视同仁。”

正解禁令的本质不是“不允许出现 Self 字样”，而是“返回对象的大小在编译期必须已知”。Box<Self> 本身是一个固定大小的指针，把未知大小的对象搬到堆上，调用方只需要搬指针。所以 Box<Self>、Rc<Self>、Arc<Self> 都不会破坏对象安全。就像承诺“送你一个密封快递盒”可以写进通兑卡，而承诺“送你本店不知尺寸的纪念章”不行。

为何常见：只背了“不返回 Self”的字面结论，没有理解背后的“大小可知性”动机。

误区“`fn new() -> Self` 一出现在 trait 里，整个 trait 就废了，编译器直接报错，啥都用不了。”

正解关联函数的定义本身合法，静态分发时 Dog::new() 照样能调。只是这个 trait 无法做成 trait 对象。若给该方法加 where Self: Sized，它就被豁免，trait 依然对象安全，只是用 dyn 调用时该方法不可用。就像“加盟申请”不印在通兑卡上，但每家门店的专属小程序里照常能用。

为何常见：把“不能用 dyn”误解为“这是非法代码”，混淆了“定义合法性”与“动态分发可用性”两个层面。

误区“动态分发是高级特性，肯定比编译器展开的泛型更快更灵活，能用 dyn 就不用泛型。”

正解恰恰相反。泛型单态化在编译期为每个类型生成专用代码，无间接跳转、可内联优化；dyn 每次调用要经过虚表查表加间接跳转，编译器还无法跨虚表内联。对象安全的价值不在性能，而在“运行时可扩展性”和“编译体积可控”。就像通兑卡方便但每笔要经过总部结算系统，专属本地卡虽然不能跨店用，但省去了结算环节。

为何常见：将“动态”与“高性能”等同，忽略了间接调用带来的真实开销。

面试题

Q1. 在 Rust 中，“对象安全”指的是什么？

单选题 · easy

  • A.防止空指针异常的安全机制
  • B.trait 能否转换为 trait 对象的规则← 正确答案
  • C.编译器对堆内存自动回收的特性
  • D.泛型代码在编译期展开的速度

答案：B。对象安全是一组约束条件，决定 trait 能否被用作 trait 对象（dyn Trait）。它和安全指针、内存回收无关。类似通兑卡能否发行的质检规则，而不是保险条款。

Q2. 下列哪种方法会让 trait 失去对象安全性？

单选题 · easy

  • A.返回 i32 类型的普通方法
  • B.带有 &self 接收者的方法
  • C.带泛型参数 T 的方法← 正确答案
  • D.返回字符串切片的方法

答案：C。方法级泛型参数意味着无穷多种实现版本，vtable 无法在编译期穷举，因此触发禁区一。返回固定类型、带 self 接收者都是安全的方法。

Q3. dyn Trait 在内存中被称为胖指针，它包含哪两部分？

单选题 · mid

  • A.数据的指针和虚表的指针← 正确答案
  • B.两个都指向数据的指针
  • C.对象长度和哈希值的元组
  • D.堆地址和栈地址的差值

答案：A。胖指针 = 数据指针 + 虚表指针。数据指针定位堆上实例，虚表指针定位方法表。这正对应奶茶通兑卡上的“门店标签”和“服务清单索引”。

Q4. 为什么返回 Self 的方法不能出现在对象安全 trait 中？

单选题 · mid

  • A.Self 关键字在 trait 中还未定义
  • B.Self 对应的类型在编译期大小未知← 正确答案
  • C.返回 Self 会破坏调用者的所有权
  • D.编译器无法推断返回值的生命周期

答案：B。动态分发时具体类型被擦除，编译器不知道 Self 有多大，栈上无法分配空间。与所有权、生命周期无关。就像通兑卡不知道纪念章尺寸，无法预分配货架。

Q5. 某个 trait 想保留 fn new() -> Self 且整体仍对象安全，正确做法是？

单选题 · hard

  • A.把 new 改名并加上 Box\<Self\> 返回
  • B.给 new 添加 where Self: Sized 约束← 正确答案
  • C.把 new 移动到另一个 crate 中
  • D.用关联常量替代 new 构造器

答案：B。where Self: Sized 让该方法被检查器豁免，静态分发可调用、dyn 不可用，trait 整体仍对象安全。改名加 Box 无法解决“无 self 接收者”问题；移动 crate 不改变规则。

Q6. 关于 Box\<dyn Error\> 在错误处理中的说法，正确的是？

单选题 · hard

  • A.它比普通错误类型慢一个数量级
  • B.它只能包装实现 Debug 的错误
  • C.它统一了不同错误类型的传播← 正确答案
  • D.它必须配合泛型函数才能使用

答案：C。Box<dyn Error> 把任意具体错误装箱成统一 trait 对象，向上传播时可忽略具体类型。它不需要泛型函数配合，性能影响也只是虚表跳转，并非“慢一个数量级”。

Q7. 泛型参数放在 trait 上（如 trait Foo\<T\>）与放在方法上有什么不同？

单选题 · easy

  • A.前者对象安全后者也对象安全
  • B.前者实例化后确定后者每次动态← 正确答案
  • C.前者编译更快后者运行更快
  • D.两者在对象安全上完全相同

答案：B。trait Foo<T> 在写成 dyn Foo<i32> 时 T 已定型，虚表可建；fn bar<U>(&self) 的方法级泛型在每次调用时才确定，虚表无法登记。这就是“卡面信息固定”与“每单定制口味”的区别。

Q8. 以下属于动态分发特点的有哪些？

多选题 · mid

  • A.运行时通过虚表查找方法地址← 正确答案
  • B.编译产物可扩展新的实现类型← 正确答案
  • C.每次调用都能内联优化
  • D.要求 trait 必须对象安全← 正确答案

答案：ABD。动态分发在运行时查虚表，可以让编译产物接受未来新类型，前提是 trait 对象安全。C 是泛型静态分发的优点，动态分发恰恰难以内联。

Q9. 下列哪些方法签名会使 trait 失去对象安全性？

多选题 · hard

  • A.fn new() -> Self← 正确答案
  • B.fn clone_me(&self) -> Self← 正确答案
  • C.fn to_str\<T: Display\>(&self) -> String← 正确答案
  • D.fn id(&self) -> u64

答案：ABC。A 无 self 且返回 Self 双违规；B 返回裸 Self 触发禁区二；C 方法级泛型触发禁区一；D 是普通方法，完全安全。

Q10. 下列哪些返回类型不破坏对象安全规则？

多选题 · mid

  • A.fn clone(&self) -> Box\<Self\>← 正确答案
  • B.fn make() -> Self where Self: Sized← 正确答案
  • C.fn build(&self) -> Self
  • D.fn size(&self) -> usize← 正确答案

答案：ABD。A 返回固定大小的 Box 指针，合法；B 带 Sized 豁免，静态可用不破坏整体；D 返回固定大小数值，合法；C 返回裸 Self 且无豁免，破坏对象安全。