导言

在 Rust 的核心设计理念中，“零成本抽象”（Zero-cost Abstraction）是一个非常重要的目标。
为了实现这一点，Rust 提供了功能强大的 泛型（Generics） 与 Trait（特征） 系统，使我们能够编写既灵活又高效的通用代码。

泛型让我们可以编写“类型无关”的函数与结构体，而 Trait 则定义了“类型必须满足的行为约束”。
它们结合在一起，使得 Rust 既具备静态类型语言的安全性，又拥有接近动态语言的表达能力。

1. 为什么需要泛型

没有泛型时，我们常常会写出重复的函数：

fn max_i32(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

fn max_f64(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

这两个函数逻辑相同，只是类型不同。泛型让我们可以写成一个版本：

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

这里的 T 是类型参数，PartialOrd 是一个 Trait 约束，表示 T 必须实现可比较行为。
泛型解决了重复代码的问题，同时保持了类型安全。

2. 泛型的使用场景

2.1 泛型函数

泛型函数的定义方式如下：

fn identity<T>(x: T) -> T {
    x
}

调用时，Rust 会自动根据传入参数推断 T 的类型。
例如：

let a = identity(10);       // T = i32
let b = identity("hello");  // T = &str

2.2 泛型结构体

除了函数，结构体也可以使用泛型：

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

使用方式：

let p1 = Point { x: 5, y: 10 };
let p2 = Point { x: 1.2, y: 3.4 };

也可以混合不同类型：

struct Point2<T, U> {
    x: T,
    y: U,
}

let p3 = Point2 { x: 5, y: 3.0 };

泛型让结构体变得更加灵活，而不必为每种类型写独立定义。

3. Trait：行为的抽象

Trait 可以理解为“接口”或“能力约束”。
它定义了某一类类型所必须实现的一组行为。

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

实现 Trait：

struct Article {
    title: String,
    author: String,
}

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

使用 Trait：

let article = Article {
    title: String::from("Rust 精要系列"),
    author: String::from("Mingyuan"),
};

println!("{}", article.summarize());

通过 Trait，我们可以在不同类型之间定义共同行为，而不需要共享基类或继承。

4. 泛型与 Trait 的结合使用

泛型和 Trait 结合是 Rust 最常用的模式之一。
下面这个函数接受任何实现了 Summary 的类型：

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

这就是所谓的 Trait Bound（特征约束）。
也可以用 where 语法提高可读性：

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

这种语法在多个约束并列时尤其清晰。

5. 多 Trait 约束

如果希望参数满足多个 Trait，可以用 + 连接：

fn show<T: Summary + Clone>(item: T) {
    println!("Item: {}", item.summarize());
}

或者使用 where：

fn show<T>(item: T)
where
    T: Summary + Clone,
{
    println!("Item: {}", item.summarize());
}

这让函数具备了灵活的多重能力约束。

6. Trait 对象与动态分发

有时我们希望函数接受不同实现同一 Trait 的类型，这时可以使用 Trait 对象：

fn print_summary(item: &dyn Summary) {
    println!("Summary: {}", item.summarize());
}

Trait 对象通过动态分发实现，也就是在运行时决定具体调用哪个实现。
这与 C++ 的虚函数或 Java 的多态行为类似，但更安全。

然而需要注意：Trait 对象要求 Trait 不能包含泛型方法或返回 Self 的方法。

7. 泛型与性能

Rust 的泛型是通过**单态化（Monomorphization）**实现的。
这意味着在编译时，Rust 会为每种具体类型生成独立的函数版本。

例如：

fn print_value<T: std::fmt::Display>(x: T) {
    println!("{}", x);
}

如果我们调用：

print_value(5);
print_value("hello");

编译后实际上会生成两个函数版本，一个针对 i32，一个针对 &str。
这就是所谓的“零成本抽象”——在运行时没有性能损耗。

8. 泛型与 Trait 的实战场景

8.1 通用容器类型

许多标准库类型本质上就是泛型，比如：

let numbers: Vec<i32> = vec![1, 2, 3];
let words: Vec<String> = vec![String::from("hello"), String::from("rust")];

Vec<T>、Option<T>、Result<T, E> 都是泛型类型，它们使得 Rust 标准库具备极高的灵活性。

8.2 实现通用算法

例如实现一个可以求任意数值类型平均值的函数：

fn average<T>(list: &[T]) -> f64
where
    T: Into<f64> + Copy,
{
    let sum: f64 = list.iter().map(|&x| x.into()).sum();
    sum / list.len() as f64
}

这里的 Trait Bound 指定 T 必须能转换成 f64，并且支持复制。

8.3 Trait 扩展与默认实现

Trait 可以提供默认实现：

trait Summary {
    fn summarize(&self) -> String {
        String::from("(No summary provided)")
    }
}

这样实现者可以选择覆盖，也可以直接使用默认版本。
这类似面向对象语言中的“抽象类默认方法”，但更安全且无运行时开销。

9. 泛型、Trait 与所有权的关系

泛型函数默认通过 静态分发 实现，这意味着在编译时决定具体函数版本。
Trait 对象则通过 动态分发（引用传递）实现。

在设计接口时：

• 若需要极致性能，使用泛型；

• 若需要灵活的运行时多态，使用 Trait 对象；

• 若需要共享数据，使用引用或智能指针（如 Arc<dyn Trait>）。

理解这些底层机制，有助于你在性能与灵活性之间做出权衡。

10. 总结

本篇文章系统介绍了 Rust 中泛型与 Trait 的核心机制与实战场景。

• 泛型让代码更通用、更可复用；

• Trait 定义了类型的共同行为，是 Rust 抽象的重要基础；

• 泛型与 Trait 的结合，实现了静态类型系统中的多态；

• Trait 对象提供运行时多态支持；

• 单态化机制保证了泛型代码没有运行时性能损失。

掌握泛型与 Trait，你就掌握了 Rust 类型系统的核心思想。
它是理解后续主题——异步编程、智能指针、并发模型等高级特性的关键前提。