Rust 泛型（Generics）学习教程

泛型是 Rust 中极具影响力的语言特性，它能让我们用同一套代码处理不同类型的数据，有效减少代码冗余、提升代码复用性，同时保持零运行时开销。本教程将从泛型的基础概念出发，逐步深入讲解其在函数、结构体、枚举、方法中的应用，以及进阶的 const 泛型特性，帮助你彻底掌握 Rust 泛型的使用。

一、为什么需要泛型？------ 从问题出发

在编程中，我们经常会遇到"同一逻辑需要处理不同类型数据"的场景。例如实现"两数相加"功能，若不使用泛型，需要为每种数据类型单独编写函数：

// 为 i8 类型实现加法
fn add_i8(a: i8, b: i8) -> i8 {
    a + b
}
// 为 i32 类型实现加法
fn add_i32(a: i32, b: i32) -> i32 {
    a + b
}
// 为 f64 类型实现加法
fn add_f64(a: f64, b: f64) -> f64 {
    a + b
}

fn main() {
    println!("i8 加法: {}", add_i8(2i8, 3i8));
    println!("i32 加法: {}", add_i32(20, 30));
    println!("f64 加法: {}", add_f64(1.23, 1.23));
}

这种写法的问题很明显：代码高度重复，若需要支持更多类型（如 i64、u32 等），会导致函数数量爆炸式增长。

而泛型的核心作用，就是提供一个"通用模板"，用一个函数替代多个重复函数。上面的代码用泛型改写后，只需一行核心逻辑：

// 泛型加法函数（暂不能直接运行，后续会修复）
fn add<T>(a: T, b: T) -> T {
    a + b
}

fn main() {
    println!("i8 加法: {}", add(2i8, 3i8));
    println!("i32 加法: {}", add(20, 30));
    println!("f64 加法: {}", add(1.23, 1.23));
}

这里的 <T> 就是泛型参数，代表"任意类型"。不过这段代码暂时无法编译，因为并非所有类型都支持"+"操作------这就涉及到泛型的"类型约束"，我们将在后续章节解决。

二、泛型基础：概念与语法

1. 什么是泛型？

泛型（Generics）是一种"参数化类型"的技术，它允许我们在定义函数、结构体、枚举时，不指定具体类型，而是用泛型参数 （如 T、U）代替，后续再通过"类型推断"或"显式指定"确定具体类型。

泛型本质是多态的一种实现，可以理解为"通用的工具"：就像坦克的炮管能发射多种炮弹，泛型代码能处理多种类型，无需为每种类型单独"定制工具"。

2. 泛型参数的声明与使用

使用泛型的核心规则：泛型参数必须先声明，后使用。

以泛型函数为例，声明泛型参数的语法是在函数名后加 <泛型参数>，例如：

// 声明泛型参数 T，再在参数和返回值中使用 T
fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest { // 暂不能编译，需添加类型约束
            largest = item;
        }
    }
    largest
}

• <T>：声明泛型参数 T（T 是 Type 的缩写，惯例用单个大写字母命名，如 T、U、V）。
• list: &[T]：参数 list 是元素类型为 T 的数组切片。
• -> T：返回值类型为 T。

3. 泛型的类型约束（Trait Bound）

为什么前面的 largest 和 add 函数无法编译？因为泛型参数 T 可以是"任意类型"，但并非所有类型都支持 >（比较）或 +（加法）操作。

解决方法是为泛型参数添加类型约束 （Trait Bound），明确要求 T 必须实现某个"特征"（Trait，类似其他语言的"接口"），只有实现该特征的类型才能使用泛型代码。

示例1：修复 largest 函数（支持比较）

比较操作需要类型实现 std::cmp::PartialOrd 特征，添加约束后代码如下：

// 为 T 添加约束：必须实现 PartialOrd 特征
fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest { // 现在编译通过，因为 T 支持比较
            largest = item;
        }
    }
    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let char_list = vec!['y', 'm', 'a', 'q'];
    
    println!("最大数字: {}", largest(&number_list)); // 100
    println!("最大字符: {}", largest(&char_list));   // 'y'
}

示例2：修复 add 函数（支持加法）

加法操作需要类型实现 std::ops::Add 特征，且需指定加法结果类型为 T（通过 Add<Output = T> 声明）：

// 约束：T 必须实现 Add 特征，且加法结果为 T
fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b // 编译通过，因为 T 支持加法
}

fn main() {
    println!("i8 加法: {}", add(2i8, 3i8));    // 5
    println!("i32 加法: {}", add(20, 30));     // 50
    println!("f64 加法: {}", add(1.23, 1.23)); // 2.46
}

类型约束的语法扩展（where 子句）

当泛型参数的约束较多时，直接写在 <T: 约束> 中会导致代码冗长。此时可以用 where 子句将约束分离，提高可读性：

// 用 where 子句简化约束
fn create_and_print<T>(val: T) 
where 
    T: From<i32> + std::fmt::Display, // T 需实现 From<i32>（从 i32 转换）和 Display（格式化输出）
{
    println!("值: {}", val);
}

4. 显式指定泛型类型

大多数情况下，Rust 编译器能通过上下文自动推断 泛型参数的具体类型。但如果推断失败（例如泛型函数无参数，无法从参数推断类型），则需要显式指定 泛型类型，语法是 函数名::<具体类型>()。

示例：显式指定泛型类型

use std::fmt::Display;

// 泛型函数：无参数，无法自动推断 T
fn create_and_print<T>() 
where 
    T: From<i32> + Display, // T 可从 i32 转换，且支持格式化输出
{
    let a: T = 100.into(); // 从 100（i32）转换为 T
    println!("a = {}", a);
}

fn main() {
    // 编译器无法推断 T，需显式指定为 i64
    create_and_print::<i64>(); // 输出：a = 100
    // 也可指定为 f64
    create_and_print::<f64>(); // 输出：a = 100
}

三、泛型的核心应用场景

泛型不仅能用于函数，还能用于结构体、枚举和方法，覆盖 Rust 中绝大多数数据结构和逻辑的定义。

1. 结构体中使用泛型

结构体的字段类型可以用泛型参数定义，语法是在结构体名后加 <泛型参数>，且所有泛型参数必须先声明。

示例1：单泛型参数的结构体（字段类型相同）

// 声明泛型参数 T，字段 x 和 y 均为 T 类型
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    // T 被推断为 i32（x 和 y 都是整数）
    let integer_point = Point { x: 5, y: 10 };
    // T 被推断为 f64（x 和 y 都是浮点数）
    let float_point = Point { x: 1.5, y: 3.0 };
    
    // 错误：x 是 i32，y 是 f64，T 无法同时代表两种类型
    // let error_point = Point { x: 5, y: 3.0 };
}

示例2：多泛型参数的结构体（字段类型不同）

若需要结构体字段类型不同，可以声明多个泛型参数（如 T、U）：

// 声明两个泛型参数 T 和 U，x 为 T 类型，y 为 U 类型
struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    // x 是 i32，y 是 f64，编译通过
    let mixed_point = Point { x: 5, y: 3.0 };
    // x 是 &str，y 是 char，编译通过
    let str_char_point = Point { x: "hello", y: 'a' };
}

注意 ：泛型参数并非越多越好。若结构体泛型参数超过 3-4 个（如 struct Foo<T, U, V, W>），建议拆分结构体，降低代码复杂度。

2. 枚举中使用泛型

枚举是 Rust 中处理"可选值"或"错误"的核心工具，而泛型让枚举能支持任意类型的值。Rust 标准库中的 Option 和 Result 就是泛型枚举的典型例子。

示例1：Option 枚举（处理"存在/不存在"的值）

// 泛型枚举 Option<T>：要么有值（Some(T)），要么无值（None）
enum Option<T> {
    Some(T),  // 存储类型为 T 的值
    None,     // 无值
}

fn main() {
    // T 为 i32：有值 5
    let some_number = Option::Some(5);
    // T 为 &str：有值 "hello"
    let some_string = Option::Some("hello");
    // 无值：需显式指定 T（编译器无法推断）
    let no_value: Option<i32> = Option::None;
}

示例2：Result 枚举（处理"成功/失败"）

Result 枚举用两个泛型参数：T 代表成功时的类型，E 代表失败时的错误类型：

// 泛型枚举 Result<T, E>：要么成功（Ok(T)），要么失败（Err(E)）
enum Result<T, E> {
    Ok(T),   // 成功：返回类型为 T 的值
    Err(E),  // 失败：返回类型为 E 的错误
}

// 模拟文件读取：成功返回 File，失败返回 IoError
fn read_file(path: &str) -> Result<File, IoError> {
    if path.exists() {
        Ok(open_file(path)) // 成功：返回 Ok(File)
    } else {
        Err(IoError::FileNotFound) // 失败：返回 Err(IoError)
    }
}

3. 方法中使用泛型

为结构体或枚举定义方法时，也可以使用泛型。核心规则与泛型函数一致：泛型参数必须先声明（在 impl 后），后使用。

示例1：为泛型结构体实现方法

struct Point<T> {
    x: T,
    y: T,
}

// 为 Point<T> 实现方法：返回 x 字段的引用
impl<T> Point<T> {
    // 方法 x() 的返回值类型为 &T
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("p.x = {}", p.x()); // 输出：p.x = 5
}

• impl<T> Point<T>：先声明泛型参数 T，再为 Point<T> 实现方法（Point<T> 是完整的结构体类型，而非 Point）。

示例2：方法中定义额外泛型参数

除了结构体本身的泛型参数，方法还可以单独定义额外的泛型参数（类似泛型函数）：

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    // 方法 mixup：额外声明泛型参数 V、W
    // 接收另一个 Point<V, W>，返回 Point<T, W>
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,       // 来自当前 Point 的 x（T 类型）
            y: other.y,      // 来自另一个 Point 的 y（W 类型）
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 }; // T=i32, U=f64
    let p2 = Point { x: "hello", y: 'c' }; // V=&str, W=char
    
    // 调用 mixup：返回 Point<i32, char>
    let p3 = p1.mixup(p2);
    println!("p3.x = {}, p3.y = {}", p3.x, p3.y); // 输出：p3.x = 5, p3.y = c
}

示例3：为具体泛型类型实现方法

可以只为泛型结构体的某个具体类型 实现方法（而非所有类型）。例如，只为 Point<f32> 实现"计算到原点距离"的方法：

struct Point<T> {
    x: T,
    y: T,
}

// 只为 Point<f32> 实现方法（其他类型无此方法）
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        // 仅 f32 支持 powi（平方）和 sqrt（开方）
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 3.0, y: 4.0 };
    println!("到原点距离: {}", p.distance_from_origin()); // 输出：5.0
    
    // 错误：Point<i32> 未实现 distance_from_origin 方法
    // let p_int = Point { x: 3, y: 4 };
    // p_int.distance_from_origin();
}

四、进阶特性：const 泛型

前面的泛型都是"针对类型的泛型"（抽象不同类型），而 Rust 1.51 版本引入的 const 泛型 是"针对值的泛型"（抽象不同值），核心用于处理"固定大小但大小可变"的数据类型（如数组）。

1. 为什么需要 const 泛型？------ 数组的痛点

在 Rust 中，数组的长度是类型的一部分 。例如 [i32; 2]（长度为 2 的 i32 数组）和 [i32; 3]（长度为 3 的 i32 数组）是完全不同的类型，这导致普通泛型无法处理"任意长度的数组"：

// 仅支持长度为 3 的 i32 数组
fn display_array(arr: [i32; 3]) {
    println!("{:?}", arr);
}

fn main() {
    let arr3 = [1, 2, 3];
    display_array(arr3); // 编译通过
    
    let arr2 = [1, 2];
    // 错误：期望 [i32; 3]，实际是 [i32; 2]
    // display_array(arr2);
}

若用普通泛型（如 fn display_array<T>(arr: [T; 3])），仍无法支持长度为 2 的数组------这时候就需要 const 泛型。

2. const 泛型的语法与使用

const 泛型的核心是用"值"作为泛型参数，语法是 const 泛型名: 值类型（值类型必须是编译期可知的整数类型，如 usize、u32 等）。

示例：用 const 泛型支持任意长度的数组

// T：类型泛型（数组元素类型）
// const N: usize：const 泛型（数组长度，值类型为 usize）
fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
    println!("{:?}", arr);
}

fn main() {
    let arr3 = [1, 2, 3];       // [i32; 3]
    let arr2 = [4.5, 5.6];      // [f64; 2]
    let arr_str = ["a", "b", "c"]; // [&str; 3]
    
    display_array(arr3);    // 输出：[1, 2, 3]
    display_array(arr2);    // 输出：[4.5, 5.6]
    display_array(arr_str); // 输出：["a", "b", "c"]
}

• const N: usize：声明 const 泛型 N，代表数组长度，值类型为 usize（数组长度的默认类型）。
• 该函数可处理任意元素类型 （T 需实现 Debug 特征以支持 {:?} 输出）和任意长度 （N 为任意 usize 值）的数组。

3. const 泛型表达式（夜间版本特性）

在夜间版本（nightly）中，const 泛型还支持const 表达式，可以用表达式动态约束泛型值。例如，限制函数参数的内存大小不超过 768 字节：

// 仅夜间版本支持：启用 const 泛型表达式特性
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

// 辅助 trait：用于判断 const 表达式结果是否为 true
pub trait IsTrue {}
impl IsTrue for Assert<true> {}

// 辅助枚举：包装 const 表达式结果
pub enum Assert<const CHECK: bool> {}

// 约束：T 的内存大小 < 768 字节
fn something<T>(val: T)
where
    Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,
{
    println!("值的大小: {} 字节", core::mem::size_of::<T>());
}

fn main() {
    something([0u8; 0]);    // 大小 0 字节：ok
    something([0u8; 512]);  // 大小 512 字节：ok
    // 错误：大小 1024 字节 > 768 字节
    // something([0u8; 1024]);
}

4. const fn 与 const 泛型结合

const fn 是"编译期可执行的函数"，与 const 泛型结合可以实现"编译期计算泛型值"，进一步提升性能。

示例：编译期计算数组长度

// 定义 const fn：编译期计算缓冲区大小（factor * 1024）
const fn compute_buffer_size(factor: usize) -> usize {
    factor * 1024
}

// 泛型结构体：缓冲区大小由 const 泛型 N 决定
struct Buffer<const N: usize> {
    data: [u8; N],
}

fn main() {
    // 编译期计算缓冲区大小：4 * 1024 = 4096 字节
    const BUFFER_SIZE: usize = compute_buffer_size(4);
    
    // 使用 const 泛型创建缓冲区
    let buffer = Buffer::<BUFFER_SIZE> {
        data: [0; BUFFER_SIZE],
    };
    
    println!("缓冲区大小: {} 字节", buffer.data.len()); // 输出：4096
}

• compute_buffer_size 在编译期执行，结果直接嵌入代码，避免运行时计算开销。
• Buffer::<BUFFER_SIZE>：用编译期计算的 BUFFER_SIZE 作为 const 泛型参数，确保缓冲区大小固定。

五、泛型的性能：零成本抽象的秘密

Rust 泛型是"零成本抽象"------使用泛型不会带来任何运行时开销，其背后的原理是单态化（Monomorphization）。

1. 什么是单态化？

单态化是 Rust 编译器在编译期执行的过程：它会遍历所有泛型代码的调用处，为每个"具体类型/具体值"生成一份专属的非泛型代码。

简单来说，编译器会把泛型代码"展开"为针对具体类型的代码，就像我们手动编写多个重复函数一样，但这个过程由编译器自动完成。

2. 单态化示例：Option 枚举

以 Option<T> 为例，若代码中使用了 Option<i32> 和 Option<f64>，编译器会生成两份 Option 枚举的代码：

// 编译器生成的单态化代码（伪代码）
enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    // 实际使用的是 Option_i32
    let integer = Option_i32::Some(5);
    // 实际使用的是 Option_f64
    let float = Option_f64::Some(5.0);
}

3. 单态化的权衡

单态化带来了"零运行时开销"的优势，但也有代价：

• 编译速度变慢：编译器需要为每个具体类型生成代码，泛型使用越频繁，编译时间越长。
• 二进制文件变大：生成的代码量增加，导致最终可执行文件体积增大（即"代码膨胀"）。

不过，这种权衡在大多数场景下是值得的------运行时性能的提升通常比编译速度和文件大小的代价更重要。