Rust的静态分发（Static Dispatch）和动态分发（Dynamic Dispatch）

知识点图片

在 Rust 中，分发（Dispatch） 指的是当代码调用一个多态函数（即通过 Trait 定义的函数）时，编译器或运行时如何决定具体执行哪个实现版本的过程。

Rust 提供了两种分发机制：静态分发（Static Dispatch） 和 动态分发（Dynamic Dispatch）。

1. 静态分发 (Static Dispatch)

静态分发是 Rust 的默认行为。编译器在编译阶段就已经知道具体调用的是哪个类型的函数实现。

机制：单态化 (Monomorphization)

当你使用泛型（Generics）约束 Trait 时，编译器会进行静态分发。编译器会根据泛型参数的具体类型，为每一种类型生成一份专门的代码副本。这个过程叫做单态化。

语法

使用泛型语法 <T: Trait> 或 impl Trait。

代码示例

plaintext

trait Speak {
    fn say(&self);
}

struct Dog;
impl Speak for Dog {
    fn say(&self) { println!("Woof!"); }
}

struct Cat;
impl Speak for Cat {
    fn say(&self) { println!("Meow!"); }
}

// 这是一个泛型函数，使用静态分发
fn make_it_speak<T: Speak>(animal: T) {
    animal.say();
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    // 编译时，Rust 会生成两个版本的 make_it_speak：
    // 1. make_it_speak_for_dog(Dog)
    // 2. make_it_speak_for_cat(Cat)
    make_it_speak(dog);
    make_it_speak(cat);
}

优缺点

优点（Pros）：
- 性能极高：函数调用是直接的，没有指针间接引用的开销。
- 内联优化：编译器可以将函数代码内联（Inline），进一步提升速度。
缺点（Cons）：
- 二进制体积膨胀：因为为每种类型都生成了重复的代码，最终的可执行文件体积会变大。
- 编译时间变长：编译器需要处理更多的代码。
- 灵活性较低：集合中只能存放同一种具体的类型（例如 Vec<T> 中的 T 必须一致）。

2. 动态分发 (Dynamic Dispatch)

动态分发是在运行阶段才确定调用哪个函数的实现。编译器在编译时不知道具体类型，只知道该类型实现了某个 Trait。

机制：Trait 对象 (Trait Objects) 与虚函数表 (Vtable)

当你使用 Trait 对象（&dyn Trait, Box<dyn Trait>, Rc<dyn Trait> 等）时，会发生动态分发。

Rust 使用胖指针（Fat Pointer）来实现这一点。一个 Trait 对象的引用包含两个指针：

指向数据本身的指针（具体类型的实例）。
指向虚函数表（vtable）的指针。vtable 包含了该类型实现该 Trait 的所有方法的函数指针。

语法

使用 dyn Trait 关键字。

代码示例

plaintext

trait Speak {
    fn say(&self);
}

struct Dog;
impl Speak for Dog { fn say(&self) { println!("Woof!"); } }

struct Cat;
impl Speak for Cat { fn say(&self) { println!("Meow!"); } }

// 这是一个使用 Trait 对象的函数，使用动态分发
// 注意参数是 &dyn Speak，而不是泛型 T
fn make_it_speak_dyn(animal: &dyn Speak) {
    animal.say(); // 运行时查表，找到对应的 say 方法
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    // 可以在同一个集合中存储不同类型，只要它们实现了 Speak
    let animals: Vec<Box<dyn Speak>> = vec![
        Box::new(dog),
        Box::new(cat),
    ];

    for animal in animals {
        // 运行时决定调用 Dog::say 还是 Cat::say
        animal.say();
    }
}

优缺点

优点（Pros）：
- 灵活性高：允许在同一个容器（如 Vec）中存储不同类型的对象（只要它们实现了相同的 Trait）。
- 二进制体积较小：不需要为每种类型生成多份代码，只有一份函数逻辑。
- 编译时间较短：编译器不需要做单态化展开。
缺点（Cons）：
- 性能稍慢：
  1. 无法内联优化。
  2. 需要通过指针进行间接调用（查 vtable），这可能导致 CPU 分支预测失败和缓存未命中。
- 对象安全（Object Safety）限制：并不是所有的 Trait 都能作为 Trait 对象使用（例如，Trait 方法不能返回 Self，不能有泛型参数等）。

3. 总结对比

特性	静态分发 (Static Dispatch)	动态分发 (Dynamic Dispatch)
关键字/语法	`<T: Trait>`, `impl Trait`	`&dyn Trait`, `Box<dyn Trait>`
实现机制	单态化 (Monomorphization)	虚函数表 (Vtable) & 胖指针
发生时间	编译时 (Compile-time)	运行时 (Runtime)
运行时开销	无 (Zero overhead)	有 (指针解引用，查表)
代码体积	较大 (代码重复)	较小 (代码复用)
灵活性	低 (同一容器只能存同一类型)	高 (同一容器可存不同类型)
编译器优化	支持内联 (Inlining)	不支持内联

4. 什么时候用哪个？

首选静态分发：
- Rust 社区的惯例是默认使用静态分发（泛型）。
- 当你追求极致性能时。
- 当你不需要在同一个变量或容器中存储不同类型的数据时。
使用动态分发：
- 当你需要异构集合（Heterogeneous Collections）时。例如：一个 UI 列表，里面既有 Button 也有 TextField，它们都实现了 Draw trait。
  plaintext
```
let components: Vec<Box<dyn Draw>> = vec![Box::new(btn), Box::new(txt)];
```
- 当泛型导致的二进制体积过大，且该部分代码不是性能热点时，可以通过改为动态分发来减小体积。
- 当你在编写插件系统，需要在运行时加载实现了特定接口的类型时。

播面