泛型函数定义 ​

核心概念 ​

泛型函数是在函数名后面用尖括号 <T> 声明类型参数的函数。类型参数 T 可以用在参数类型、返回类型和函数体中,代表一个在调用时才确定的具体类型。泛型函数通常需要通过 trait bound 来约束类型参数可以执行的操作——没有任何约束的 T 只能做移动、引用等最基本的操作,加上 Clone 才能克隆,加上 PartialOrd 才能比较大小。

rust
// 基本泛型函数: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");
}

类型参数的声明位置 ​

rust
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> 或给变量加类型标注。

rust
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 子句可以让签名更清晰。

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

泛型函数中的引用参数 ​

rust
// 引用参数: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);
}

返回泛型类型 ​

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

基本示例 ​

用泛型函数构建一组通用的集合操作工具:

rust
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 是泛型函数的常见搭配,让函数既灵活又高效。