rust

《深入Rust系统编程》2.5 泛型与trait

泛型和 trait 是 Rust 中用于编写灵活、可重用代码的强大工具。泛型允许开发者编写可以处理多种数据类型的代码，而 trait 则允许开发者定义共享的行为。

Leeting Yan 2025-01-14 5 分钟阅读 2065 字

2.5 泛型与 trait

2.5.1 泛型

泛型是 Rust 中用于编写可以处理多种数据类型的代码的机制。泛型使用尖括号 (<T>) 表示，其中 T 是类型参数。

1. 泛型函数:

泛型函数可以接受任意类型的参数，并返回任意类型的值：

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

2. 泛型结构体:

泛型结构体可以包含任意类型的字段：

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
}

3. 泛型枚举:

泛型枚举可以包含任意类型的变体：

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");
}

2.5.2 trait

trait 是 Rust 中用于定义共享行为的机制。trait 类似于其他语言中的接口，但更加强大和灵活。

1. 定义 trait:

trait 使用 trait 关键字定义，其基本语法如下：

trait TraitName {
    fn method1(&self) -> ReturnType;
    fn method2(&self, param: ParamType) -> ReturnType;
    // ...
}

TraitName 是 trait 的名称，遵循 Rust 的命名规范。
method1, method2 是 trait 的方法，每个方法都需要指定参数类型和返回类型。

2. 实现 trait:

可以使用 impl 关键字为类型实现 trait：

struct StructName {
    // ...
}

impl TraitName for StructName {
    fn method1(&self) -> ReturnType {
        // 方法实现
    }

    fn method2(&self, param: ParamType) -> ReturnType {
        // 方法实现
    }
}

3. 默认方法:

trait 可以定义默认方法，这些方法可以被实现 trait 的类型覆盖：

trait TraitName {
    fn method1(&self) -> ReturnType {
        // 默认方法实现
    }
}

4. trait 作为参数:

trait 可以作为函数参数，允许函数接受任何实现了该 trait 的类型：

fn function_name(param: impl TraitName) {
    // 函数体
}

5. trait bound:

trait bound 用于指定泛型类型必须实现的 trait：

fn function_name<T: TraitName>(param: T) {
    // 函数体
}

2.5.3 关联类型与高级 trait 特性

1. 关联类型（Associated Types）：

关联类型在 trait 定义中声明一个类型占位符，实现者为其指定具体类型。这比泛型参数更简洁，因为一个类型只需实现一次 trait。

trait Iterator {
    type Item;           // 关联类型
    fn next(&mut self) -> Option<Self::Item>;
}

// 为自定义类型实现 Iterator
struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;     // 指定关联类型为 u32

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

关联类型 vs 泛型参数：

特性	关联类型	泛型参数
实现次数	一个类型只能实现一次	可多次（不同泛型参数）
语法简洁度	调用时无需指定类型	需显式指定或推断
典型应用	Iterator、Add、Deref	Vec、HashMap<K, V>
灵活性	低（固定映射）	高（动态组合）

2. Supertrait（trait 继承）：

// OutlinePrint 继承 Display，实现者必须同时实现 Display
trait OutlinePrint: std::fmt::Display {
    fn outline_print(&self) {
        let output = self.to_string();
        let len = output.len();
        println!("{}", "*".repeat(len + 4));
        println!("*{}*", " ".repeat(len + 2));
        println!("* {} *", output);
        println!("*{}*", " ".repeat(len + 2));
        println!("{}", "*".repeat(len + 4));
    }
}

3. 孤儿规则（Orphan Rules）：

Rust 规定：当 trait 和实现该 trait 的类型至少有一个定义在本地 crate 中时，才能写 impl。这避免了第三方 crate 升级后 trait 实现冲突的问题。

// ✅ 允许：自定义 trait + 外部类型
trait MyTrait {}
impl MyTrait for String {}   // String 是标准库的，但 MyTrait 是本地的

// ✅ 允许：外部 trait + 自定义类型
impl std::fmt::Display for MyStruct {}

// ❌ 不允许：外部 trait + 外部类型（违反孤儿规则）
// impl std::fmt::Display for String {}

4. Blanket Implementation（泛型 blanket impl）：

// 为所有实现了 Display 的类型自动实现 ToString trait（标准库已存在）
impl<T: std::fmt::Display> ToString for T {
    // ...
}

// 自定义 blanket impl：所有可 Clone 的类型实现 MyTrait
trait MyTrait {
    fn duplicate(&self) -> Self;
}
impl<T: Clone> MyTrait for T {
    fn duplicate(&self) -> Self {
        self.clone()
    }
}

2.5.4 完整实战：自定义集合与 trait 组合

// 定义一个可比较大小的 trait
trait Measurable {
    fn measure(&self) -> usize;
}

// 为多种类型实现
trait Summarizable {
    fn summary(&self) -> String;
}

// 泛型结构体，要求类型同时实现多个 trait
struct Report<T: Measurable + Summarizable> {
    item: T,
    timestamp: u64,
}

impl<T: Measurable + Summarizable> Report<T> {
    fn generate(&self) -> String {
        format!(
            "[{}] {} (measure={})",
            self.timestamp,
            self.item.summary(),
            self.item.measure()
        )
    }
}

// 简化写法：where 子句（适用于复杂 bound）
fn process<T>(item: T) -> String
where
    T: Measurable + Summarizable + Clone,
{
    format!("Processed: {}", item.summary())
}

2.5.5 总结

1. 泛型函数:

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

2. 泛型结构体:

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    println!("integer_point.x = {}", integer_point.x());

    let float_point = Point { x: 1.0, y: 4.0 };
    println!("float_point.x = {}", float_point.x());
}

3. 泛型枚举:

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");

    match some_number {
        Some(x) => println!("some_number is {}", x),
        None => println!("some_number is None"),
    }

    match some_string {
        Some(s) => println!("some_string is {}", s),
        None => println!("some_string is None"),
    }
}

4. 定义 trait:

trait Summary {
    fn summarize(&self) -> String;
}

5. 实现 trait:

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

6. trait 作为参数:

fn notify(item: impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };

    notify(tweet);
}

7. trait bound:

fn notify<T: Summary>(item: T) {
    println!("Breaking news! {}", item.summarize());
}

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };

    notify(tweet);
}

2.5.5 总结

泛型和 trait 是 Rust 类型系统的两大支柱。泛型提供参数化多态，让代码摆脱具体类型的束缚；trait 提供接口抽象，定义可复用的行为契约。从基础泛型函数到关联类型、supertrait、blanket impl，Rust 的 trait 系统比传统接口更灵活、更具表达力。

学习路线图建议：

先掌握泛型函数和泛型结构体的基本写法
深入理解 trait bound 和 where 子句的使用场景
学习标准库核心 trait（Iterator、Display、Debug、Clone、Default）的实现模式
研究关联类型在设计 API 时的优势（对比泛型参数）
理解孤儿规则对工程实践的约束，避免设计上的死胡同
尝试编写 blanket impl，体会 Rust “为已有类型添加新能力"的强大

以下是一些学习 Rust 泛型和 trait 的资源：

Rust 官方文档: https://doc.rust-lang.org/book/ch10-00-generics.html
Rust by Example: https://doc.rust-lang.org/rust-by-example/generics.html
The Rust Programming Language Book: https://doc.rust-lang.org/book/ch10-02-traits.html

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章返回首页

2.5 泛型与 trait

2.5.1 泛型

2.5.2 trait

2.5.3 关联类型与高级 trait 特性

2.5.4 完整实战：自定义集合与 trait 组合

2.5.5 总结

2.5.5 总结

探索更多技术文章

「rust」更多文章