22. 泛型与 trait 基础

  • 理解泛型的作用。
  • 定义泛型函数、结构体和方法。
  • 理解 trait 是什么。
  • 实现 trait 并使用 trait bound。
  • 初步了解泛型与性能的关系。

假设要写两个函数,分别返回 i32 和 char 的最大值:

snippet.rust
fn largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}
 
fn largest_char(list: &[char]) -> char {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

逻辑完全相同,只是类型不同。泛型可以避免重复。

snippet.rust
fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

<T> 声明类型参数,函数体中使用 T 代替具体类型。

snippet.rust
struct Point<T> {
    x: T,
    y: T,
}
 
fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

如果 x 和 y 可能不同类型:

snippet.rust
struct Point<T, U> {
    x: T,
    y: U,
}
snippet.rust
struct Point<T> {
    x: T,
    y: T,
}
 
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

注意 impl<T> 中也要写 <T>。

trait 定义了一组类型必须实现的方法,类似于其他语言中的接口:

snippet.rust
pub trait Summary {
    fn summarize(&self) -> String;
}
snippet.rust
pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}
 
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

trait 可以提供默认实现:

snippet.rust
pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

实现时可以选择覆盖或直接使用默认。

使用泛型时,可以约束类型必须实现某些 trait:

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

多个 trait bound:

snippet.rust
pub fn notify<T: Summary + Display>(item: &T) {}

或者使用 where 子句:

snippet.rust
pub fn notify<T>(item: &T)
where
    T: Summary + Display,
{
    println!("Breaking news! {}", item.summarize());
}

Rust 在编译时通过单态化(monomorphization) 将泛型代码转换为具体类型的代码。因此泛型不会带来运行时性能损失。

snippet.rust
let integer = Some(5);
let float = Some(5.0);

编译后等价于两个不同的 Option 类型。

概念 作用 示例
泛型 减少重复代码 Vec<T>
trait 定义共享行为 Summary
trait bound 约束类型能力 T: Summary
单态化 编译期展开泛型 无运行时开销
  1. 为什么泛型需要 trait bound 才能比较大小?
  2. 为一个自定义类型实现标准库中的 Display trait。
  3. where 子句和直接写在 <> 中的 trait bound 有什么区别?

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • rust/泛型与_trait_基础.txt
  • 最后更改: 2026/08/12 23:35
  • 由 张叶安