行为抽象——Trait、泛型与多态

上文我们大致了解了"文字地牢"小游戏的核心数据模型，那么我们本章的目标是使用 Trait 定义通用行为；理解泛型的单态化（monomorphization）与性能；对比 trait 对象与泛型参数。

基本概念

Trait（特质）

Trait是Rust中定义共享行为的方式，类似于其他语言中的接口。它允许我们定义类型必须实现的方法集合。

Trait的特点：

1. 定义共享行为：多个类型可以实现同一个trait
2. 零成本抽象：trait方法调用在编译时解析，没有运行时开销
3. 默认实现：可以为trait方法提供默认实现
4. 关联类型：trait可以定义与实现类型相关的类型

泛型

泛型允许我们编写适用于多种类型的代码，而无需为每种类型重复编写相同的逻辑。

泛型的优势：

1. 代码复用：编写一次，适用于多种类型
2. 类型安全：编译时检查类型正确性
3. 性能：通过单态化实现零成本抽象
4. 灵活性：支持trait约束和复杂类型关系

多态

Rust通过trait和泛型提供多态性，允许我们编写更灵活和可重用的代码。

Rust中的多态类型：

1. 静态多态：通过泛型实现，编译时确定具体类型
2. 动态多态：通过trait对象实现，运行时确定具体类型

Trait对象

Trait对象（dyn Trait）允许我们在运行时处理不同类型的对象，实现动态分发。

Trait对象的特点：

1. 动态分发：运行时确定调用的具体方法
2. 类型擦除：隐藏具体类型信息
3. 堆分配：通常需要通过 Box等智能指针存储

如何使用

定义和实现Trait

// 定义trait
pub trait Drawable {
    fn draw(&self);
    fn area(&self) -> f64;
  
    // 默认实现
    fn description(&self) -> String {
        format!("A shape with area {}", self.area())
    }
}

// 实现trait
struct Circle {
    radius: f64,
}

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
  
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

使用泛型

// 泛型函数
fn duplicate<T: Clone>(value: T) -> (T, T) {
    (value.clone(), value)
}

// 使用where子句
fn compare<T>(a: T, b: T) -> bool 
where 
    T: PartialEq 
{
    a == b
}

// 多个trait约束
fn process<T>(item: T) 
where 
    T: Clone + std::fmt::Debug 
{
    println!("{:?}", item);
}

使用Trait对象

// 使用trait对象
fn render_shapes(shapes: Vec<Box<dyn Drawable>>) {
    for shape in shapes {
        shape.draw();
        println!("Area: {}", shape.area());
    }
}

// 创建trait对象向量
let shapes: Vec<Box<dyn Drawable>> = vec![
    Box::new(Circle { radius: 5.0 }),
    Box::new(Rectangle { width: 10.0, height: 20.0 }),
];

Trait 作为行为接口

pub trait Actor {
    fn position(&self) -> Position;
    fn set_position(&mut self, p: Position);
  
    // 默认实现
    fn move_by(&mut self, dx: i32, dy: i32) {
        let mut pos = self.position();
        pos.x = (pos.x as i32 + dx) as usize;
        pos.y = (pos.y as i32 + dy) as usize;
        self.set_position(pos);
    }
}

impl Actor for Player {
    fn position(&self) -> Position { self.position }
    fn set_position(&mut self, p: Position) { self.position = p; }
}

要点：

• trait 描述"能做什么"，不关心"如何做"。
• 可提供默认方法，降低实现者负担；为对象安全考虑，尽量将需要的 API 设计为不依赖泛型的签名。

泛型与单态化

1. 泛型：fn move_entity<T: Actor>(entity: &mut T, dx: i32, dy: i32) 编译期为每个 T 生成专用代码（单态化），零虚调用开销。
2. 动态分发：异构集合使用 dyn Trait（如 Vec<Box<dyn Actor>>），以间接调用换取灵活性。

示例：

fn move_entity<T: Actor>(entity: &mut T, dx: i32, dy: i32) {
    let mut p = entity.position();
    p.x = (p.x as i32 + dx) as usize;
    p.y = (p.y as i32 + dy) as usize;
    entity.set_position(p);
}

注意事项

1. Trait中的方法默认需要被实现，除非提供了默认实现。
2. 泛型函数在编译时会为每种使用的类型生成专门的代码，可能导致代码膨胀。
3. 使用 dyn Trait时需要注意对象安全的要求。
4. 在设计trait时要考虑其用途，是用于静态分发还是动态分发。
5. 泛型约束可以通过 where子句来表达，提高代码可读性。
6. Trait对象需要堆分配，可能影响性能。
7. 泛型函数的编译时间可能较长，特别是约束复杂的泛型。
8. 在使用trait对象时，要注意trait必须是对象安全的。

本项目中的使用

在我们的项目中，虽然目前还没有大量使用trait和泛型，但我们可以预见它们在扩展游戏功能时的价值。例如，我们可以定义一个Actor trait来统一玩家和敌人的行为：

pub trait Actor {
    fn position(&self) -> Position;
    fn set_position(&mut self, p: Position);
  
    // 默认实现移动方法
    fn move_by(&mut self, dx: i32, dy: i32) {
        let mut pos = self.position();
        // 注意边界检查和碰撞检测
        pos.x = (pos.x as i32 + dx) as usize;
        pos.y = (pos.y as i32 + dy) as usize;
        self.set_position(pos);
    }
}

这将使我们能够编写适用于玩家和敌人的通用代码。

扩展应用示例

在地牢探险游戏中，我们可以使用trait和泛型来实现：

1. 统一的实体接口：

pub trait Entity {
    fn position(&self) -> Position;
    fn render_symbol(&self) -> char;
    fn is_blocking(&self) -> bool;
}

2. 泛型的碰撞检测：

fn check_collision<T: Entity, U: Entity>(a: &T, b: &U) -> bool {
    a.position() == b.position() && (a.is_blocking() || b.is_blocking())
}

3. 动态实体集合：

struct GameWorld {
    entities: Vec<Box<dyn Entity>>,
}

性能考虑

1. 泛型优势：

   • 编译时优化
   • 无虚函数调用开销
   • 可内联

2. Trait对象适用场景：

   • 异构集合
   • 运行时多态
   • 减少代码膨胀

高级特性

关联类型

trait Graph {
    type Node;
    type Edge;
  
    fn neighbors(&self, n: &Self::Node) -> Vec<Self::Node>;
}

泛型关联类型（GAT）

trait Iterable {
    type Iterator<'a>: Iterator<Item = &'a str> where Self: 'a;
    fn iter(&self) -> Self::Iterator<'_>;
}

选择策略

• 性能敏感且类型明确：泛型参数。
• 需要在容器中混合不同实现：dyn Trait。

示例（混合容器）：

let mut actors: Vec<Box<dyn Actor>> = Vec::new();
actors.push(Box::new(player));
actors.push(Box::new(enemy));

实际应用建议

1. 优先使用泛型：在类型已知的情况下，泛型提供更好的性能
2. 合理使用trait对象：在需要运行时多态时使用
3. 设计良好的trait：保持trait简洁，提供有用的默认实现
4. 考虑对象安全性：设计trait时考虑是否需要作为trait对象使用

练习：

1. 新增 Enemy 并实现 Actor；用 Vec<Box<dyn Actor>> 存放玩家与敌人。
2. 编写 take_turn(&mut GameState) 行为，模拟敌人向玩家接近。

概念补充

• 约束与 where 子句：fn f<T>(t: T) where T: Actor + Debug 提升可读性，复杂约束建议放在 where。
• 关联类型 vs 泛型参数：Iterator<Item = T> 用关联类型表达"与实现强绑定"的输出；当需为同一 trait 多次实现不同输出时再考虑泛型参数。
• 对象安全与 dyn Trait：含有泛型方法或 Self: Sized 的方法不对象安全；为 dyn Actor 设计 API 时可提供"对象安全"子集。
• 自定默认方法：trait 可提供默认实现，通过最小化必需集使实现者负担更小。
• 自动 trait：Send/Sync 由编译器根据字段自动推断；跨线程共享/移动需满足这些约束。
• blanket impl 及孤儿规则：为外部类型实现外部 trait 被禁止（coherence）；可使用 newtype 包装规避。
• 性能注意：泛型单态化避免虚调用；dyn 带来间接调用和可能的不可内联，换取灵活性。