目录

22. 泛型与 trait 基础

学习目标

22.1 为什么需要泛型

假设要写两个函数,分别返回 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
}

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

22.2 泛型函数

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 代替具体类型。

22.3 泛型结构体

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,
}

22.4 泛型方法

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

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

22.5 trait 是什么

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

snippet.rust
pub trait Summary {
    fn summarize(&self) -> String;
}

22.6 实现 trait

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)
    }
}

22.7 默认实现

trait 可以提供默认实现:

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

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

22.8 trait bound

使用泛型时,可以约束类型必须实现某些 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());
}

22.9 泛型与性能

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

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

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

22.10 小结

概念 作用 示例
泛型 减少重复代码 Vec<T>
trait 定义共享行为 Summary
trait bound 约束类型能力 T: Summary
单态化 编译期展开泛型 无运行时开销

22.11 思考题

  1. 为什么泛型需要 trait bound 才能比较大小?
  2. 为一个自定义类型实现标准库中的 Display trait。
  3. where 子句和直接写在 <> 中的 trait bound 有什么区别?