Rust中的特征Trait

Trait（特征） 是用于定义一组可以被不同类型实现的 行为（行为约定）（类似于其他语言的接口或抽象类）， 是Rust中实现代码复用、接口抽象的核心机制，主要特性包括：

• 定义类型行为的方法集合（支持默认实现）。
• 通过泛型约束实现静态分发，通过 Trait 对象实现动态分发。
• 关联类型简化泛型使用，默认泛型支持运算符重载。
• 孤儿规则确保代码安全，Super Trait 支持 Trait 间依赖。

Trait基础

Trait定义

使用 trait 关键字定义 Trait，内部可包含：

• 方法签名（无实现）：实现该 Trait 的类型必须实现此方法；
• 带默认实现的方法：现该 Trait 的类型可重写（也可使用默认实现）；
• trait方法都是公开的（无需pub修饰）；
• 使用trait方法时，需要引用此trait（use crate::tait_test::Speak;）

mod trait_test;
    
pub trait Speak {
    fn speak(&self);

    // 不用pub
    fn say(&self) {
        println!("default say in trait");
    }
}

Trait实现

使用 impl Trait for Type 语法为具体类型实现 Trait。实现时必须提供 Trait 中所有无默认实现的方法，有默认实现的方法可选择性重写。

• 孤儿规则（Orphan Rule）：为避免冲突，只有Trait或类型定义所在crate中才可以实现trait；即不能为两个外部实体（要为类型 A 实现特征 T，那么 A 或者 T 至少有一个是在当前作用域中定义的！）实现关联；
• 类型实现多个trait时：每类Trait都要独立的impl实现；

pub struct Person {
}

// 使用默认实现的say
// 方法不需要加pub
impl Speak for Person {
    fn speak(&self) {
        println!("Person is speaking");
    }
}

pub struct Dog {
}

// 重置trait中的say
impl Speak for Dog {
    fn speak(&self) {
        println!("Dog is speaking");
    }

    fn say(&self) {
        println!("Dog is saying");
    }
}

Trait继承

一个 Trait 依赖另一个 Trait 的功能（类似"继承"），可以通过 Trait: SuperTrait 语法声明其为 "父特征"（多个SuperTrait可用+连接）。

trait Animal {
    fn eat(&self);
}

// 实现Mammal的类型，也必须实现Animal
trait Mammal: Animal {
    fn walk(&self);
}

// 多个父特征
trait CloneMammal: Mammal+Clone {
    fn clone_fun(&self);
}

若一个类型实现了Mammal，则必须同时实现Animal：

impl Mammal for Dog {
    fn walk(&self) {
        println!("Dog is walking");
    }
}

impl Animal for Dog {
    fn eat(&self) {
        println!("Dog is eating");
    }
}

Trait参数

Trait 可以作为函数参数的约束，要求参数必须是 "实现了某 Trait 的类型"，这一特性称为静态分发（Static Dispatch）。

有多个trait约束时，使用+连接。

写法	名称	编译行为	核心区别
impl Trait	静态分发	编译时确定具体类型	编译器为每种类型生成专用版本（模板展开）
dyn Trait	动态分发	运行时通过虚表调用	使用间接跳转实现多态（虚函数）

impl trait方式

直接声明参数类型为 "实现了某 Trait 的类型"，适合简单场景。

pub fn to_say(t: &(impl Speak + Animal)) {
    t.say();
    t.eat();
}

泛型约束方式

使用泛型参数 + Trait 约束，适合需要复用类型参数的场景（如多个参数需要相同类型）。

pub fn to_speak<T: Speak>(t: &T) {
    t.speak();
}

// where方式
pub fn to_walk<T>(t: &T)
where
    T: Mammal + Speak,
{
    t.walk();
}

dyn trait方式

在有些情况下，需要使用dyn trait参数来替代impl trait：

需要处理多种不同类型的集合时

trait Drawable {
    fn draw(&self);
}

// 使用 dyn Trait 处理不同类型
fn render_shapes(shapes: &[&dyn Drawable]) {
    for shape in shapes {
        shape.draw();
    }
}

避免代码膨胀

// 使用 dyn 减少二进制大小
fn log_debug(obj: &dyn Debug) {
    println!("Debug: {:?}", obj);
}

// 会被数百种类型调用（若使用impl，则会为每种类型生成一个实现）
log_debug(&42);
log_debug(&"hello");
log_debug(&vec![1, 2, 3]);

Trait返回类型

使用 impl Trait 可以声明函数返回 "实现了某 Trait 的类型"，但只能返回一种具体类型（即使有多个类型实现了该 Trait）

pub fn gen_speak() -> impl Speak
{
    Dog{}
}

若要实现返回多种类型（都实现了同一Trait），则需要使用Box+dyn。

pub fn gen_dyn_speak(choice: bool) -> Box<dyn Speak>
{
    if choice {
        Box::new(Dog{})
    } else {
        Box::new(Person{})
    }
}

Trait对象

需要不同实现 Trait 的类型存放在一起时，可以使用 Trait 对象（动态分发）：

let animals: Vec<Box<dyn Speak>> = vec![
    Box::new(Dog),
    Box::new(Person),
];

for a in animals {
    a.say(); // 多态行为
}

dyn Trait

dyn Trait 表示"某种在运行时确定的实现了 Trait 的类型"。内部通过 虚函数表（vtable） 实现动态分发。

Trait 要成为 对象安全（object safe， 能做成 **dyn Trait**），必须满足 ：

• trait 中的方法不能有 Self 作为返回类型；
• 方法不能是泛型函数。

trait Bad {
    fn new() -> Self;     // ❌ 返回 Self
    fn print<T>(&self);   // ❌ 泛型方法
}

关联类型

Trait 中可以用 type 关键字定义关联类型，表示 Trait 中使用的 "抽象类型"，具体类型由实现 Trait 的类型指定。

实现一个迭代器trait，最终类型由具体实现类型决定：

// Item为关联类型，由实现类型具体定义
pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

pub struct Counter {
    start: u32,
    end: u32,
}

impl Counter {
    pub fn new(last: u32) -> Self {
        Self {
            start: 0,
            end: last,
        }
    }
}

impl Iterator for Counter {
    type Item = u32; // 此时指定Item的真实类型

    fn next(&mut self) -> Option<Self::Item> {
        if self.start >= self.end {
            return None;
        }

        self.start += 1;
        Some(self.start)
    }
}

fn main() {
    let mut c = tait_test::Counter::new(5);
    while let Some(i) = c.next() {
        println!("i: {}", i);
    }
}    

派生特征（Derived Trait）

派生特征（Derived Traits） 是一种通过 `#[derive] 属性自动为类型（结构体、枚举等）生成特征实现的机制。它允许编译器为特定特征自动生成默认实现，无需手动编写重复代码。

为类型添加 #[derive(Trait1, Trait2, ...)] 属性，即可自动实现指定的特征

// 为结构体派生 Debug 和 PartialEq 特征
#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

可派生Trait一览：

Trait	含义	示例
Debug	打印调试信息，用于 {:?}	println!("{:?}", obj);
Clone	可通过 .clone() 复制	let b = a.clone();
Copy	可通过简单赋值复制（浅拷贝）	let b = a;
PartialEq	实现 == 与 != 比较	a == b
Eq	完全等价（无 NaN 等特殊情况）	自动与 PartialEq 搭配
PartialOrd	实现 <, <=, > 比较	a < b
Ord	完全可排序	需满足传递性
Hash	可用于 HashMap 键	自动哈希字段
Default	提供默认值 T::default()
serde::Serialize / serde::Deserialize	(外部库) 序列化/反序列化	JSON/YAML转换

限制与手动实现

派生特征的自动实现是 "通用默认逻辑"，但存在局限性：

• 逻辑固定：自动实现基于字段 / 变体的递归处理；
• 依赖字段：若类型包含未实现目标特征的字段，则无法派生（需手动为字段类型实现特征，或改为手动实现目标特征）

#[derive(Debug)]
struct User {
    id: u32,
    name: String,
}

// 手动实现 PartialEq，仅比较 id（忽略 name）
impl PartialEq for User {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for User {} // 因 PartialEq 满足完全相等，可实现 Eq

fn main() {
    let u1 = User { id: 1, name: "Alice".to_string() };
    let u2 = User { id: 1, name: "Bob".to_string() };
    
    println!("u1 == u2: {}", u1 == u2); // 输出：true（仅比较 id）
}

自定义派生特征

需要使用过程宏（proc-macro） ，通过 derive 宏生成自定义实现代码。需要把 proc-macro 放在单独的 crate 。

workspace/
  ├─ t_example/      # 普通库，定义 trait/types，re-export derive
  ├─ t_derive/       # proc-macro crate（proc-macro = true）
  └─ test/           # 使用示例

1、新建proc-macro crate

• cargo new t_derive --lib
• 修改toml：添加proc-macro与依赖

[package]
name = "t_derive"
version = "0.1.0"
edition = "2024"

[lib]
proc-macro = true

[dependencies]
proc-macro2 = "1.0.101"
quote = "1.0.41"
syn = "2.0.106"

• 在lib.rs中添加macro代码

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

// 实现派生宏
#[proc_macro_derive(HelloTrait)]
pub fn derive_hello_trait(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident; // 获取类型名称
    
    // 生成特征实现代码
    let expanded = quote! {
        impl HelloTrait for #name {
            fn hello(&self) -> String {
                format!("Hello from {}", stringify!(#name))
            }
        }
    };
    
    TokenStream::from(expanded)
}

2、新建trait定义crate

• cargo new t_example --lib
• 修改toml：添加依赖

[package]
name = "t_example"
version = "0.1.0"
edition = "2024"

[dependencies]
t_derive = {path = "../t_derive"}

• 在lib.rs中定义trait

pub trait HelloTrait {
    fn hello(&self) -> String;
}

// 可选：把 derive 重导出，用户只依赖t_example即可直接使用#[derive(HelloTrait)]
pub use t_derive::HelloTrait;

3、使用trait

• cargo new test
• 修改toml：添加依赖

[dependencies]
t_example = {path = "../t_example"}

• 派生trait

use t_example::HelloTrait;

#[derive(HelloTrait)]
struct MyStruct {}


fn main() {
    let ms = MyStruct {};
    println!("{}", ms.hello()); // ello from MyStruct
}