泛型函数定义
核心概念
泛型函数是在函数名后面用尖括号 <T> 声明类型参数的函数。类型参数 T 可以用在参数类型、返回类型和函数体中,代表一个在调用时才确定的具体类型。泛型函数通常需要通过 trait bound 来约束类型参数可以执行的操作——没有任何约束的 T 只能做移动、引用等最基本的操作,加上 Clone 才能克隆,加上 PartialOrd 才能比较大小。
// 基本泛型函数:T 没有约束,只能传递和返回
fn identity<T>(value: T) -> T {
value
}
// 带 trait bound 的泛型函数:T 必须可以比较大小
fn max_of_two<T: PartialOrd>(a: T, b: T) -> T {
if a > b { a } else { b }
}
// 多个 trait bound:T 必须可以比较大小 + 可以打印
fn print_max<T: PartialOrd + std::fmt::Display>(a: T, b: T) {
if a > b {
println!("较大值: {}", a);
} else {
println!("较大值: {}", b);
}
}
fn main() {
// identity 可以接受任何类型
let n = identity(42);
let s = identity("hello");
let v = identity(vec![1, 2, 3]);
println!("n={}, s={}, v={:?}", n, s, v);
// max_of_two 可以接受任何实现了 PartialOrd 的类型
println!("max: {}", max_of_two(10, 20));
println!("max: {}", max_of_two('a', 'z'));
println!("max: {}", max_of_two(3.14, 2.72));
// print_max 需要 PartialOrd + Display
print_max(100, 200);
print_max("apple", "banana");
}类型参数的声明位置
use std::fmt::Display;
// 类型参数在函数名后的尖括号中声明
// ↓ 声明位置
fn show<T: Display>(value: T) {
println!("{}", value);
}
// 多个类型参数
fn pair<A, B>(a: A, b: B) -> (A, B) {
(a, b)
}
// 类型参数可以用在多个位置
fn repeat_value<T: Clone>(value: T, count: usize) -> Vec<T> {
// ↑ 参数类型 ↑ 返回类型中
vec![value; count]
}
fn main() {
show(42);
show("hello");
show(3.14);
let p = pair(1, "two");
println!("{:?}", p);
let nums = repeat_value(7, 5);
println!("{:?}", nums);
let words = repeat_value(String::from("hi"), 3);
println!("{:?}", words);
}类型推断与 turbofish
编译器大多数时候能自动推断泛型的具体类型。当推断不出来时,可以用 turbofish 语法 ::<Type> 或给变量加类型标注。
fn parse_value<T: std::str::FromStr>(input: &str) -> Option<T> {
input.parse::<T>().ok()
}
fn create_default<T: Default>() -> T {
T::default()
}
fn main() {
// 编译器自动推断
let x = parse_value::<i32>("42"); // turbofish 指定 T = i32
let y = parse_value::<f64>("3.14"); // turbofish 指定 T = f64
let z = parse_value::<bool>("true"); // turbofish 指定 T = bool
println!("x={:?}, y={:?}, z={:?}", x, y, z);
// 通过变量类型标注推断
let a: Option<i32> = parse_value("100");
let b: Option<u8> = parse_value("255");
println!("a={:?}, b={:?}", a, b);
// create_default 必须指定类型(无法从参数推断)
let n: i32 = create_default(); // 类型标注
let s = create_default::<String>(); // turbofish
let v = create_default::<Vec<i32>>(); // turbofish
println!("n={}, s='{}', v={:?}", n, s, v);
}where 子句
当 trait bound 很长或有多个类型参数时,用 where 子句可以让签名更清晰。
use std::fmt::{Debug, Display};
use std::ops::Add;
// 尖括号中写 bound(短的时候可以)
fn short_bound<T: Display + Clone>(value: T) -> (T, T) {
let clone = value.clone();
println!("{}", value);
(value, clone)
}
// where 子句(bound 较长时更清晰)
fn long_bound<T, U>(t: T, u: U) -> String
where
T: Display + Clone + Debug,
U: Display + Into<String>,
{
format!("{} and {}", t, u)
}
// 复杂的 where 子句
fn combine_and_add<A, B, R>(a: A, b: B) -> R
where
A: Into<R>,
B: Into<R>,
R: Add<Output = R>,
{
a.into() + b.into()
}
fn main() {
let (a, b) = short_bound(42);
println!("a={}, b={}", a, b);
let result = long_bound(100, String::from("hello"));
println!("{}", result);
// combine_and_add: 将两个值转为同一类型后相加
let sum: f64 = combine_and_add(10i32, 20i32);
println!("sum: {}", sum);
}泛型函数中的引用参数
// 引用参数:T 本身不需要 Clone
fn first<T>(slice: &[T]) -> Option<&T> {
slice.first()
}
fn last<T>(slice: &[T]) -> Option<&T> {
slice.last()
}
// 查找满足条件的元素
fn find<T, F>(slice: &[T], predicate: F) -> Option<&T>
where
F: Fn(&T) -> bool,
{
for item in slice {
if predicate(item) {
return Some(item);
}
}
None
}
// 计算满足条件的元素数量
fn count_if<T, F>(slice: &[T], predicate: F) -> usize
where
F: Fn(&T) -> bool,
{
slice.iter().filter(|item| predicate(item)).count()
}
// 带生命周期的泛型函数
fn longer<'a, T: std::fmt::Debug>(a: &'a [T], b: &'a [T]) -> &'a [T] {
if a.len() >= b.len() { a } else { b }
}
fn main() {
let nums = vec![1, 5, 3, 8, 2, 9];
println!("第一个: {:?}", first(&nums));
println!("最后一个: {:?}", last(&nums));
// 查找第一个大于 5 的
let found = find(&nums, |&n| n > 5);
println!("第一个 > 5: {:?}", found);
// 统计偶数个数
let even_count = count_if(&nums, |&n| n % 2 == 0);
println!("偶数个数: {}", even_count);
// 字符串切片也可以
let words = vec!["apple", "banana", "cherry"];
let long_word = find(&words, |w| w.len() > 5);
println!("长单词: {:?}", long_word);
// 带生命周期
let a = vec![1, 2, 3];
let b = vec![4, 5, 6, 7];
let result = longer(&a, &b);
println!("更长的: {:?}", result);
}返回泛型类型
use std::collections::HashMap;
// 返回 impl Trait(返回一个实现了某 trait 的具体类型)
fn make_greeting(formal: bool) -> impl std::fmt::Display {
if formal {
String::from("您好,欢迎光临")
} else {
String::from("嗨!")
}
}
// 返回泛型收集器(通过调用者决定收集为什么类型)
fn double_values<T>(values: &[i32]) -> T
where
T: std::iter::FromIterator<i32>,
{
values.iter().map(|&x| x * 2).collect()
}
// 通过 Default 创建并返回
fn create_and_fill<T: Default + std::ops::AddAssign<i32>>(n: i32) -> T {
let mut result = T::default();
for i in 0..n {
result += i;
}
result
}
fn main() {
let greeting = make_greeting(true);
println!("{}", greeting);
// 同一个函数,不同的收集类型
let as_vec: Vec<i32> = double_values(&[1, 2, 3, 4]);
println!("Vec: {:?}", as_vec);
// collect 的灵活性
let nums = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("doubled: {:?}", doubled);
}基本示例
用泛型函数构建一组通用的集合操作工具:
use std::fmt::Display;
// 泛型排序并返回新 Vec(不修改原切片)
fn sorted<T: Ord + Clone>(slice: &[T]) -> Vec<T> {
let mut result = slice.to_vec();
result.sort();
result
}
// 去重并排序
fn unique_sorted<T: Ord + Clone>(slice: &[T]) -> Vec<T> {
let mut result = slice.to_vec();
result.sort();
result.dedup();
result
}
// 分区:将元素分为满足条件和不满足条件两组
fn partition<T, F>(slice: &[T], predicate: F) -> (Vec<&T>, Vec<&T>)
where
F: Fn(&T) -> bool,
{
let mut yes = Vec::new();
let mut no = Vec::new();
for item in slice {
if predicate(item) {
yes.push(item);
} else {
no.push(item);
}
}
(yes, no)
}
// 分组:按键函数分组
fn group_by<T, K, F>(slice: &[T], key_fn: F) -> std::collections::HashMap<K, Vec<&T>>
where
K: std::hash::Hash + Eq,
F: Fn(&T) -> K,
{
let mut groups = std::collections::HashMap::new();
for item in slice {
let key = key_fn(item);
groups.entry(key).or_insert_with(Vec::new).push(item);
}
groups
}
// 打印表格
fn print_table<T: Display>(headers: &[&str], rows: &[Vec<T>]) {
// 打印表头
let header_line: Vec<String> = headers.iter()
.map(|h| format!("{:>10}", h))
.collect();
println!("{}", header_line.join(" | "));
println!("{}", "-".repeat(header_line.join(" | ").len()));
// 打印数据行
for row in rows {
let row_line: Vec<String> = row.iter()
.map(|v| format!("{:>10}", v))
.collect();
println!("{}", row_line.join(" | "));
}
}
fn main() {
// sorted
let data = vec![5, 2, 8, 1, 9, 3];
println!("排序前: {:?}", data);
println!("排序后: {:?}", sorted(&data));
println!("原数据: {:?}", data); // 原数据不变
let words = vec!["cherry", "apple", "banana"];
println!("排序: {:?}", sorted(&words));
// unique_sorted
let with_dups = vec![3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
println!("\n去重排序: {:?}", unique_sorted(&with_dups));
// partition
let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let (evens, odds) = partition(&nums, |&n| n % 2 == 0);
println!("\n偶数: {:?}", evens);
println!("奇数: {:?}", odds);
// group_by
let scores = vec![
("张三", 95), ("李四", 88), ("王五", 72),
("赵六", 91), ("钱七", 85), ("孙八", 68),
];
let groups = group_by(&scores, |&&(_, score)| {
if score >= 90 { "优秀" }
else if score >= 80 { "良好" }
else if score >= 60 { "及格" }
else { "不及格" }
});
println!("\n=== 成绩分组 ===");
for (grade, students) in &groups {
let names: Vec<&str> = students.iter()
.map(|&&(name, _)| name)
.collect();
println!(" {}: {:?}", grade, names);
}
// print_table
println!();
print_table(
&["名称", "价格", "数量"],
&[
vec!["键盘", "299", "50"],
vec!["鼠标", "99", "100"],
vec!["显示器", "2999", "20"],
],
);
}常见问题
问题一:泛型函数和接受 trait 对象的函数有什么区别?
| 特性 | 泛型函数 fn f<T: Trait>(x: T) | trait 对象 fn f(x: &dyn Trait) |
|---|---|---|
| 分发方式 | 静态分发(编译时) | 动态分发(运行时) |
| 代码生成 | 每种类型一份 | 共用一份 |
| 性能 | 可内联优化 | 有虚表开销 |
| 二进制大小 | 可能较大 | 较小 |
| 调用语法 | 普通调用 | 需要引用或 Box |
问题二:为什么裸的 T 几乎什么都做不了?
因为编译器不知道 T 具体是什么类型,也就不知道它有哪些方法。必须通过 trait bound 告诉编译器 T 具备哪些能力。没有 bound 的 T 只能做移动、传递引用等最基本的操作。
问题三:泛型函数可以有默认的类型参数吗?
函数的泛型参数不支持默认值。只有结构体、枚举和 trait 的泛型参数可以有默认值(如 struct Foo<T = i32>)。函数的类型参数必须由调用时推断或显式指定。
问题四:impl Trait 作参数和泛型有什么区别?
fn f(x: impl Display) 是 fn f<T: Display>(x: T) 的语法糖,大多数情况等价。但泛型可以让调用者用 turbofish 指定类型,impl Trait 不行。另外同一个参数用两次时,泛型保证是同一类型,impl Trait 不保证。
适用场景
- 通用算法:排序、查找、过滤、分组等
- 工具函数:swap、clamp、identity 等
- 类型转换:parse、from、into 等
- 集合操作:map、filter、fold 等
注意事项
- 泛型参数需要 trait bound 才能使用类型的方法
where子句让复杂的 bound 更易读- turbofish
::<Type>在编译器无法推断时使用 - 泛型函数会单态化,每种类型生成一份代码
- 引用参数
&T不需要T: Clone impl Trait是泛型的语法糖,但有细微差异
总结
泛型函数通过在函数名后的尖括号中声明类型参数,实现一份代码处理多种类型。类型参数通过 trait bound 约束可执行的操作,没有约束的 T 只能做最基本的传递。where 子句在 bound 复杂时提供更清晰的写法。编译器通常能自动推断类型参数,推断不出来时用 turbofish ::<Type> 显式指定。泛型函数通过单态化生成特定类型的代码,运行时没有额外开销。引用参数 &[T] 和闭包参数 F: Fn(&T) -> bool 是泛型函数的常见搭配,让函数既灵活又高效。