Rust语言进阶之核心特性：dyn用法实例(六十五)

简介： CSDN博客专家、《Android系统多媒体进阶实战》一书作者

新书发布：《Android系统多媒体进阶实战》🚀
优质专栏： Audio工程师进阶系列【原创干货持续更新中……】🚀
优质专栏： 多媒体系统工程师系列【原创干货持续更新中……】🚀
优质视频课程：AAOS车载系统+AOSP14系统攻城狮入门视频实战课 🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

🌻1.前言

本篇目的：Rust语言进阶之核心特性：dyn用法实例

🌻2. Rust核心特性dyn介绍

1. 基本定义
   dyn是Rust中的一个关键字，用于表示动态分发（dynamic dispatch）类型的指针。它与Rust的 trait 系统紧密相关。当我们使用 dyn 关键字时，表示该类型实现了某个 trait，但类型具体是什么在编译时无法确定，而是直到运行时才能确定。这种动态特性允许程序在运行时根据实际类型做出决策，而不是在编译时进行静态类型检查。dyn 使得Rust在保持静态类型检查的同时，能够处理一些需要动态类型信息的场景。

2. 与 trait 对象的关系
   dyn 关键字通常用于创建 trait 对象。Trait 对象是指针或引用，它们指向实现了特定 trait 的类型的实例。通过使用 dyn，Rust允许开发者在不直接知道类型的情况下，操作这些 trait 对象。这使得 Rust 能够实现某种形式的多态性，允许程序处理多种不同的类型，只要这些类型实现了相同的 trait。Trait 对象通过动态分发机制调用方法，避免了静态分发时类型信息的严格要求。

3. 性能与开销
   与静态类型相比，使用 dyn 关键字会引入一定的性能开销，因为它依赖于运行时动态分发。具体来说，Rust通过虚拟函数表（vtable）来实现动态分发，这种机制使得每次调用 trait 方法时，都会查找相应的函数指针。虽然这种分发方式增加了运行时开销，但它也为Rust提供了更大的灵活性，允许处理一些需要动态行为的复杂情况。然而，这种动态分发的开销通常是可控的，且可以通过显式的性能优化措施来减少影响。

4. 静态分发与动态分发的对比
   Rust的默认行为是通过静态分发来调用方法，这意味着在编译时，编译器就确定了方法调用的具体实现。然而，使用 dyn 时，Rust转向动态分发，意味着方法的具体实现直到运行时才能确定。静态分发的优势在于性能较高，因为编译器可以在编译期进行优化，而动态分发则提供了更大的灵活性和可扩展性。dyn 关键字通过牺牲一些性能换取了更加灵活的多态机制，适用于那些类型在编译时未知或多变的场景。

5. 与所有权和借用的关系
   使用 dyn 创建的 trait 对象通常会作为指针或引用使用，它们可以是拥有所有权的 Box，也可以是借用的引用（如 &dyn Trait）。Rust中的所有权和借用规则同样适用于这些 trait 对象。通过 dyn，Rust能够处理动态类型的借用和所有权，同时保持严格的内存安全和生命周期检查。虽然 trait 对象允许动态类型操作，但它们依然受到Rust的所有权和借用机制的约束，避免了内存泄漏和悬垂引用等问题。

🌻3. 代码实例

🐓3.1 创建 Trait 对象（动态分发）

• 1.应用场景：在 Rust 中，使用 dyn 创建 trait 对象，可以实现 动态分发。这意味着类型的具体实现不再在编译时确定，而是在运行时决定。通过 trait 对象，可以使代码支持多态，这对于需要处理多种类型的场景非常有用
• 2.通用语法：

let obj: &dyn TraitName = &some_type_instance;

• 3.用法实例

trait Speak {
    fn speak(&self);
}

struct Dog;
struct Cat;

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

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

fn make_speak(animal: &dyn Speak) {
    animal.speak();
}

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

    make_speak(&dog);  // 输出 "Woof!"
    make_speak(&cat);  // 输出 "Meow!"
}

在上面的例子中，我们使用了 &dyn Speak 来创建 trait 对象。通过 &dyn Speak，我们可以让 make_speak 函数接受任何实现了 Speak trait 的类型，无论它是什么类型。
dyn 的使用使得在运行时能够根据实际的类型（如 Dog 或 Cat）来调用适当的 speak 方法。

🐓3.2 通过 Box 实现 Trait 对象的所有权传递

• 1.应用场景：使用 Box，可以将 trait 对象放入堆上，从而获得动态大小类型的所有权。这常用于需要将多态对象存储在堆上的场景，或者当你希望将不同类型的对象存储在相同的数据结构中时，Box 提供了灵活的选择
• 2.通用语法：

let obj: Box<dyn TraitName> = Box::new(some_type_instance);

• 3.用法实例

trait Draw {
    fn draw(&self);
}

struct Circle;
struct Square;

impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing a circle!");
    }
}

impl Draw for Square {
    fn draw(&self) {
        println!("Drawing a square!");
    }
}

fn draw_shape(shape: Box<dyn Draw>) {
    shape.draw();
}

fn main() {
    let circle = Circle;
    let square = Square;

    let boxed_circle: Box<dyn Draw> = Box::new(circle);
    let boxed_square: Box<dyn Draw> = Box::new(square);

    draw_shape(boxed_circle);  // 输出 "Drawing a circle!"
    draw_shape(boxed_square);  // 输出 "Drawing a square!"
}

Box 用于将具体类型（如 Circle 或 Square）封装成 trait 对象。这样，我们可以将这两种不同类型的对象作为 Box 传递给 draw_shape 函数。
Box 允许动态类型的存储和传递，灵活地处理多种类型的数据。

🐓3.3 在 Trait 中使用 dyn 来支持复杂的多态

• 1.应用场景：在某些情况下，Rust 的 trait 对象可以嵌套或包含复杂的行为。在实现动态多态时，使用 dyn 可以有效地处理复杂类型之间的依赖和交互，尤其是当多个 trait 对象需要一起工作时。
• 2.通用语法：

trait TraitA {
    fn method_a(&self);
}

trait TraitB {
    fn method_b(&self);
}

struct StructA;
struct StructB;

impl TraitA for StructA {
    fn method_a(&self) {
        println!("StructA method_a");
    }
}

impl TraitB for StructB {
    fn method_b(&self) {
        println!("StructB method_b");
    }
}

fn perform_actions(a: &dyn TraitA, b: &dyn TraitB) {
    a.method_a();
    b.method_b();
}

fn main() {
    let a = StructA;
    let b = StructB;

    perform_actions(&a, &b);  // 输出 "StructA method_a" 和 "StructB method_b"
}

🐓3.4 用法总结