泛型概念 ​

核心概念 ​

泛型(Generics)是一种参数化类型的机制——编写代码时不指定具体类型,而是用一个类型占位符(通常是 T)来代替,在使用时由编译器根据上下文推断或由调用者显式指定具体类型。泛型让你写一份代码就能处理多种类型,避免为每种类型重复编写相同逻辑的函数或数据结构。Rust 的泛型是零成本抽象——编译器会为每种实际使用的类型生成专门的代码(单态化),运行时没有任何额外开销。

rust
// 没有泛型时:需要为每种类型写重复的函数
fn max_i32(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

fn max_f64(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

fn max_char(a: char, b: char) -> char {
    if a > b { a } else { b }
}

// 有泛型时:一个函数处理所有可比较的类型
fn max_generic<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

fn main() {
    // 没有泛型:每种类型调用不同的函数
    println!("i32: {}", max_i32(10, 20));
    println!("f64: {}", max_f64(3.14, 2.72));
    println!("char: {}", max_char('a', 'z'));

    // 有泛型:同一个函数处理所有类型
    println!("i32: {}", max_generic(10, 20));
    println!("f64: {}", max_generic(3.14, 2.72));
    println!("char: {}", max_generic('a', 'z'));
    println!("str: {}", max_generic("hello", "world"));
}

为什么需要泛型 ​

代码复用 ​

rust
// 没有泛型:交换两个值需要为每种类型写一遍
fn swap_i32(a: &mut i32, b: &mut i32) {
    let temp = *a;
    *a = *b;
    *b = temp;
}

fn swap_string(a: &mut String, b: &mut String) {
    let temp = a.clone();
    *a = b.clone();
    *b = temp;
}

// 有泛型:一个函数搞定
fn swap<T: Clone>(a: &mut T, b: &mut T) {
    let temp = a.clone();
    *a = b.clone();
    *b = temp;
}

fn main() {
    let mut x = 10;
    let mut y = 20;
    swap(&mut x, &mut y);
    println!("交换后: x={}, y={}", x, y);

    let mut s1 = String::from("hello");
    let mut s2 = String::from("world");
    swap(&mut s1, &mut s2);
    println!("交换后: s1={}, s2={}", s1, s2);
}

类型安全 ​

泛型在编译时确定具体类型,不会出现运行时类型不匹配的问题。

rust
// 泛型保证类型一致
fn pick<T>(condition: bool, left: T, right: T) -> T {
    if condition { left } else { right }
}

fn main() {
    // 两个参数和返回值类型必须相同
    let num = pick(true, 10, 20);       // T = i32
    let text = pick(false, "a", "b");   // T = &str

    println!("num: {}, text: {}", num, text);

    // 以下会编译错误:类型不匹配
    // let mixed = pick(true, 10, "hello");  // i32 和 &str 不一致
}

泛型的基本语法 ​

类型参数的命名惯例 ​

参数名惯例含义使用场景
TType(类型)通用类型参数
EError(错误)错误类型
KKey(键)键值对中的键
VValue(值)键值对中的值
SState(状态)状态类型
RReturn(返回值)返回类型
rust
use std::collections::HashMap;

// T:通用类型
fn identity<T>(value: T) -> T {
    value
}

// K, V:键值对
fn insert_and_get<K: std::hash::Hash + Eq + Clone, V: Clone>(
    map: &mut HashMap<K, V>,
    key: K,
    value: V,
) -> V {
    map.insert(key.clone(), value.clone());
    map.get(&key).unwrap().clone()
}

// T, E:值和错误
fn try_parse<T: std::str::FromStr>(input: &str) -> Result<T, T::Err> {
    input.parse::<T>()
}

fn main() {
    // 类型推断
    let x = identity(42);         // T = i32
    let y = identity("hello");    // T = &str
    println!("x={}, y={}", x, y);

    // 显式指定类型(turbofish 语法)
    let n = identity::<i32>(100);
    let s = identity::<&str>("world");
    println!("n={}, s={}", n, s);

    // try_parse 显式指定目标类型
    let num: Result<i32, _> = try_parse("42");
    let float: Result<f64, _> = try_parse("3.14");
    println!("num={:?}, float={:?}", num, float);
}

单态化(Monomorphization) ​

Rust 编译器在编译时会为泛型函数使用到的每种具体类型生成一份专门的代码,这个过程叫单态化。这意味着泛型代码和手写的特定类型代码有完全相同的运行时性能。

rust
// 泛型函数
fn add_one<T: std::ops::Add<Output = T> + From<i32>>(x: T) -> T {
    x + T::from(1)
}

// 编译器看到以下调用后,会生成两个具体版本:
// fn add_one_i32(x: i32) -> i32 { x + 1 }
// fn add_one_f64(x: f64) -> f64 { x + 1.0 }

fn main() {
    let a = add_one(10);     // 编译器生成 i32 版本
    let b = add_one(3.14);   // 编译器生成 f64 版本

    println!("a={}, b={}", a, b);
}
特性Rust 泛型(单态化)动态分发(trait 对象)
代码生成每种类型生成一份共用一份代码
运行时开销无有虚函数表查找
二进制大小可能较大较小
编译时间可能较长较短
内联优化可以内联通常不能内联

泛型在标准库中的应用 ​

标准库大量使用泛型,最常见的有:

rust
fn main() {
    // Vec<T>:存储任意类型的动态数组
    let nums: Vec<i32> = vec![1, 2, 3];
    let words: Vec<&str> = vec!["hello", "world"];
    println!("nums: {:?}", nums);
    println!("words: {:?}", words);

    // Option<T>:可能有值,也可能没有
    let some_num: Option<i32> = Some(42);
    let no_num: Option<i32> = None;
    println!("some: {:?}, none: {:?}", some_num, no_num);

    // Result<T, E>:成功或失败
    let ok: Result<i32, String> = Ok(100);
    let err: Result<i32, String> = Err(String::from("错误"));
    println!("ok: {:?}, err: {:?}", ok, err);

    // HashMap<K, V>:键值对集合
    use std::collections::HashMap;
    let mut scores: HashMap<String, u32> = HashMap::new();
    scores.insert(String::from("张三"), 95);
    scores.insert(String::from("李四"), 88);
    println!("scores: {:?}", scores);

    // Box<T>:堆上分配
    let boxed: Box<i32> = Box::new(42);
    let boxed_str: Box<String> = Box::new(String::from("hello"));
    println!("boxed: {}, boxed_str: {}", boxed, boxed_str);
}

多个类型参数 ​

rust
// 两个类型参数
fn first_of_pair<A, B>(pair: (A, B)) -> A {
    pair.0
}

fn second_of_pair<A, B>(pair: (A, B)) -> B {
    pair.1
}

// 自定义的键值对
#[derive(Debug)]
struct Pair<A, B> {
    first: A,
    second: B,
}

impl<A, B> Pair<A, B> {
    fn new(first: A, second: B) -> Self {
        Pair { first, second }
    }

    fn into_tuple(self) -> (A, B) {
        (self.first, self.second)
    }
}

// 三个类型参数
#[derive(Debug)]
struct Triple<A, B, C> {
    a: A,
    b: B,
    c: C,
}

fn main() {
    let pair = Pair::new("name", 42);
    println!("pair: {:?}", pair);

    let (name, age) = pair.into_tuple();
    println!("name={}, age={}", name, age);

    // 不同类型的组合
    let p1 = Pair::new(1, "hello");          // Pair<i32, &str>
    let p2 = Pair::new(true, 3.14);          // Pair<bool, f64>
    let p3 = Pair::new(vec![1, 2], Some(3)); // Pair<Vec<i32>, Option<i32>>
    println!("{:?}", p1);
    println!("{:?}", p2);
    println!("{:?}", p3);

    let triple = Triple { a: 1, b: "two", c: 3.0 };
    println!("{:?}", triple);
}

基本示例 ​

用泛型实现一个通用的容器和工具函数集合:

rust
use std::fmt;

// 泛型容器:持有一个值并记录访问次数
#[derive(Debug)]
struct Tracked<T> {
    value: T,
    access_count: u32,
}

impl<T> Tracked<T> {
    fn new(value: T) -> Self {
        Tracked { value, access_count: 0 }
    }

    fn get(&mut self) -> &T {
        self.access_count += 1;
        &self.value
    }

    fn get_mut(&mut self) -> &mut T {
        self.access_count += 1;
        &mut self.value
    }

    fn set(&mut self, value: T) {
        self.value = value;
        self.access_count += 1;
    }

    fn access_count(&self) -> u32 {
        self.access_count
    }

    fn into_inner(self) -> T {
        self.value
    }
}

// 为实现了 Display 的 T 添加额外方法
impl<T: fmt::Display> Tracked<T> {
    fn print(&mut self) {
        self.access_count += 1;
        println!("值: {} (第{}次访问)", self.value, self.access_count);
    }
}

// 泛型函数:在集合中查找满足条件的第一个元素
fn find_first<T, F>(items: &[T], predicate: F) -> Option<&T>
where
    F: Fn(&T) -> bool,
{
    for item in items {
        if predicate(item) {
            return Some(item);
        }
    }
    None
}

// 泛型函数:将一个值重复 n 次
fn repeat<T: Clone>(value: T, n: usize) -> Vec<T> {
    vec![value; n]
}

// 泛型函数:zip 两个切片
fn zip_slices<A: Clone, B: Clone>(a: &[A], b: &[B]) -> Vec<(A, B)> {
    a.iter().zip(b.iter())
        .map(|(x, y)| (x.clone(), y.clone()))
        .collect()
}

fn main() {
    // Tracked 容器
    let mut counter = Tracked::new(0);
    *counter.get_mut() += 10;
    *counter.get_mut() += 5;
    println!("值: {}, 访问次数: {}", counter.get(), counter.access_count());

    let mut name = Tracked::new(String::from("Rust"));
    name.print();
    name.set(String::from("Rust 2026"));
    name.print();
    println!("总访问次数: {}", name.access_count());

    // find_first
    let nums = vec![1, 5, 3, 8, 2, 9, 4];
    let first_big = find_first(&nums, |&n| n > 6);
    println!("第一个大于6的: {:?}", first_big);

    let words = vec!["apple", "banana", "cherry", "date"];
    let long_word = find_first(&words, |w| w.len() > 5);
    println!("第一个长单词: {:?}", long_word);

    // repeat
    let zeros = repeat(0, 5);
    let hellos = repeat(String::from("hello"), 3);
    println!("zeros: {:?}", zeros);
    println!("hellos: {:?}", hellos);

    // zip_slices
    let names = vec!["张三", "李四", "王五"];
    let scores = vec![95, 88, 76];
    let pairs = zip_slices(&names, &scores);
    for (name, score) in &pairs {
        println!("  {} : {} 分", name, score);
    }
}

常见问题 ​

问题一:泛型有运行时开销吗?

没有。Rust 通过单态化在编译时为每种具体类型生成专门的代码,运行时和手写特定类型的代码性能完全相同。但会增加编译时间和二进制文件大小。

问题二:T 必须叫 T 吗?

不是。类型参数可以用任何合法的标识符,但惯例是用大写字母:T 表示通用类型,K 和 V 用于键值对,E 用于错误类型。多个参数时也常用 A、B、C 等。

问题三:泛型和 trait 对象(dyn Trait)有什么区别?

泛型在编译时确定类型(静态分发),trait 对象在运行时确定类型(动态分发)。泛型性能更好但二进制更大,trait 对象更灵活但有虚表开销。

问题四:什么是 turbofish 语法?

function::<Type>(args) 这种写法叫 turbofish(::<>像一条鱼),用于在编译器无法自动推断类型时显式指定泛型参数的具体类型。

适用场景 ​

  • 容器类型:Vec、HashMap、Option、Result 等
  • 通用算法:排序、查找、比较等不依赖具体类型的逻辑
  • 工具函数:swap、clamp、repeat 等通用操作
  • 库 API 设计:让调用者决定具体类型

注意事项 ​

  • 泛型参数通常需要 trait bound 来约束可以执行的操作
  • 没有 trait bound 的泛型 T 几乎做不了任何事(不能打印、比较、复制等)
  • 单态化会增加编译时间和二进制大小
  • 过多的泛型参数会让代码难以阅读
  • turbofish 语法 ::<Type> 用于显式指定类型
  • 编译器通常能自动推断泛型的具体类型

总结 ​

泛型是 Rust 中实现代码复用和类型安全的核心机制。通过类型参数化,一份代码可以处理多种类型,避免重复。Rust 的泛型采用单态化策略——编译器为每种实际使用的类型生成专门的代码,运行时没有任何额外开销。泛型参数通常需要 trait bound 来约束可以进行的操作。标准库中的 Vec<T>、Option<T>、Result<T, E>、HashMap<K, V> 等都是泛型的典型应用。泛型是后续学习泛型函数、泛型结构体、泛型枚举和泛型方法的基础。