假设要写两个函数,分别返回 i32 和 char 的最大值:
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 }
逻辑完全相同,只是类型不同。泛型可以避免重复。
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 代替具体类型。
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 可能不同类型:
struct Point<T, U> { x: T, y: U, }
struct Point<T> { x: T, y: T, } impl<T> Point<T> { fn x(&self) -> &T { &self.x } }
注意 impl<T> 中也要写 <T>。
trait 定义了一组类型必须实现的方法,类似于其他语言中的接口:
pub trait Summary { fn summarize(&self) -> String; }
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 可以提供默认实现:
pub trait Summary { fn summarize(&self) -> String { String::from("(Read more...)") } }
实现时可以选择覆盖或直接使用默认。
使用泛型时,可以约束类型必须实现某些 trait:
pub fn notify<T: Summary>(item: &T) { println!("Breaking news! {}", item.summarize()); }
多个 trait bound:
pub fn notify<T: Summary + Display>(item: &T) {}
或者使用 where 子句:
pub fn notify<T>(item: &T) where T: Summary + Display, { println!("Breaking news! {}", item.summarize()); }
Rust 在编译时通过单态化(monomorphization) 将泛型代码转换为具体类型的代码。因此泛型不会带来运行时性能损失。
let integer = Some(5); let float = Some(5.0);
编译后等价于两个不同的 Option 类型。
| 概念 | 作用 | 示例 |
| 泛型 | 减少重复代码 | Vec<T> |
| trait | 定义共享行为 | Summary |
| trait bound | 约束类型能力 | T: Summary |
| 单态化 | 编译期展开泛型 | 无运行时开销 |
Display trait。where 子句和直接写在 <> 中的 trait bound 有什么区别?