深入浅出 Rust 泛型：从入门到实战

深入浅出 Rust 泛型：从入门到实战

在 Rust 编程中，泛型是实现代码复用、保证类型安全的重要特性之一。与其他语言的泛型相比，Rust 泛型基于编译期单态化实现，无运行时开销，这也是 Rust 泛型的一大优势。本文将从基础概念出发，逐步深入泛型的用法、约束、进阶技巧，并结合实战示例逐步掌握 Rust 泛型。

为什么需要泛型？

泛型的本质是类型参数化，将代码中的具体类型替换为一个占位符，在使用时再传入具体的类型。简单来说，就是“写一次代码，适配多种类型”。

举个直观的例子：如果我们需要实现一个“返回两个值中较大者”的函数，若不使用泛型，需要为每个类型单独编写函数：

// 针对 i32 类型的最大值函数
fn max_i32(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

// 针对 f64 类型的最大值函数
fn max_f64(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

这种写法会产生大量重复代码，且后续新增类型时需要持续修改。而通过泛型，我们可以编写一个通用的 max 函数，适配所有支持“大于比较”的类型：

fn max<T>(a: T, b: T) -> T
where
    T: PartialOrd, // 约束：T 必须实现 PartialOrd 特征，支持比较
{
    if a > b { a } else { b }
}

基本用法

Rust 泛型可应用于函数、结构体、枚举、方法等多种场景，核心语法是通过 <T> 声明类型参数，再通过 where 子句添加约束。

泛型函数

这里直接举一个简单示例：实现一个通用的打印值的函数，适配任意实现了 Display 特征：

use std::fmt::Display;

// 泛型函数：打印任意可显示的类型
fn print_value<T: Display>(value: T) {
    println!("值：{}", value);
}

fn main() {
    print_value(123); // 输出：值：123
    print_value("hello rust"); // 输出：值：hello rust
    print_value(3.14); // 输出：值：3.14
}

这里的 <T: Display> 是简化的约束写法，等价于 where T: Display，用于限制 T 必须实现 Display 特征。

fn print_value<T>(value: T)
where
    T: Display,
{
    println!("值：{}", value);
}

泛型结构体

泛型结构体允许结构体的字段使用类型参数，使结构体能够适配多种类型的字段。例如，实现一个通用的包装器结构体，用于包裹任意类型的值：

// 泛型结构体：Wrapper包含一个任意类型T的字段
struct Wrapper<T> {
    inner: T,
}

// 为泛型结构体实现方法
impl<T> Wrapper<T> {
    // 创建一个新的 Wrapper 实例
    fn new(inner: T) -> Self {
        Wrapper { inner }
    }

    // 获取内部值的引用
    fn get_inner(&self) -> &T {
        &self.inner
    }
}

fn main() {
    let int_wrapper = Wrapper::new(456);
    println!("int包装器的值：{}", int_wrapper.get_inner());

    let str_wrapper = Wrapper::new(String::from("Rust泛型"));
    println!("str包装器的值：{}", str_wrapper.get_inner());
}

注意：为泛型结构体实现方法时，必须在 impl 后声明类型参数 <T>，否则编译器无法识别 T 的含义。

泛型枚举

Rust 中最经典的泛型枚举就是 Option 和 Result，它们通过泛型适配不同类型的返回值。我们可以自定义一个类似的泛型枚举：

// 泛型枚举：表示“成功”或“失败”，失败时携带错误信息
enum Result<T, E> {
    Ok(T),  // 成功：携带类型为T的值
    Err(E), // 失败：携带类型为E的错误信息
}

// 测试
fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Result::Err("除数不能为0")
    } else {
        Result::Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Result::Ok(value) => println!("计算结果：{}", value), // 输出：计算结果：5
        Result::Err(err) => println!("错误：{}", err),
    }

    match divide(10, 0) {
        Result::Ok(value) => println!("计算结果：{}", value),
        Result::Err(err) => println!("错误：{}", err), // 输出：错误：除数不能为0
    }
}

泛型约束

泛型的灵活性需要通过“约束”来限制，否则编译器无法确定类型参数支持哪些操作。

简洁约束（冒号语法）

直接在类型参数后加冒号，指定需要实现的特征，适用于单个约束：

// T 必须实现 Display 和 Clone 两个特征（多个特征用+连接）
fn print_and_clone<T: Display + Clone>(value: T) {
    println!("值：{}", value);
    // 因为T实现了 Clone，所以可以调用 clone 方法
    let cloned = value.clone(); 
}

where 子句约束

当约束较多或逻辑复杂时，使用 where 子句更清晰，适用于多个类型参数、多个约束的场景：

use std::fmt::Display;

// 多个类型参数，多个约束
fn compare_and_print<T, U>(a: T, b: U)
where
    T: Display + PartialOrd<U>, // 显式约束 T 可与 U 比较
    U: Display,
{
    if a < b {
        println!("{} < {}", a, b);
    } else {
        println!("{} >= {}", a, b);
    }
}

fn main() {
    compare_and_print(10, 20); // 输出：10 < 20
    compare_and_print(3.14, 2.99); // 输出：3.14 >= 2.99
    compare_and_print("apple", "banana"); // 输出：apple < banana
}

where 子句的优势的是可以将约束与函数签名分离，使代码更易读，尤其适合泛型参数较多的场景。

泛型进阶：关联类型与默认类型参数

除了基础用法，Rust 泛型还有两个实用的进阶特性：关联类型和默认类型参数，进一步提升泛型的灵活性。

关联类型（Associated Types）

关联类型是特征中定义的关联类型，用于将特征与一个具体类型绑定，避免泛型参数过多导致的冗余。最典型的例子是标准库中的 Iterator 特征：

// 标准库中的 Iterator（简化版）
trait Iterator {
    type Item; // 关联类型：表示迭代器返回的元素类型

    // 返回下一个元素
    fn next(&mut self) -> Option<Self::Item>;
}

// 实现一个迭代器：生成1..n的整数
struct Counter {
    current: i32,
    max: i32,
}

impl Iterator for Counter {
    type Item = i32; // 绑定关联类型为i32

    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.max {
            let res = self.current;
            self.current += 1;
            Some(res)
        } else {
            None
        }
    }
}

fn main() {
    let mut counter = Counter { current: 1, max: 5 };
    while let Some(num) = counter.next() {
        println!("{}", num); // 输出：1 2 3 4
    }
}

关联类型与泛型参数的区别：关联类型是特征的一部分，一个特征只能有一个关联类型；而泛型参数是函数/结构体的一部分，可以有多个。关联类型更适合一个特征对应一个核心类型的场景，减少泛型参数的冗余。

默认类型参数

默认类型参数允许为泛型参数指定一个默认值，当使用时不传入具体类型时，就使用默认值。这在需要向后兼容、默认适配常见类型等场景中非常实用。

// 泛型结构体：默认类型为i32
struct MyContainer<T = i32> {
    data: T,
}

impl<T> MyContainer<T> {
    fn new(data: T) -> Self {
        MyContainer { data }
    }
}

fn main() {
    // 不指定类型，使用默认的 i32
    let container1 = MyContainer::new(100);
    // 显式指定类型为 String
    let container2 = MyContainer::<String>::new(String::from("默认类型参数"));
}

注意：默认类型参数只是默认值，用户可以显式指定其他类型，不会限制泛型的灵活性。

实战：用泛型实现通用数据过滤器

结合前文的泛型约束、闭包用法，我们实现一个通用的数据过滤器，支持对任意类型的集合进行过滤，可通过闭包传入自定义过滤规则，适配不同类型的数据筛选场景，更贴近实际开发需求。

// 泛型过滤函数：接收一个集合和一个过滤闭包，返回符合条件的元素组成的新集合
// T：集合中元素的类型
// F：闭包类型
fn filter<T, F>(collection: &[T], mut predicate: F) -> Vec<T>
where
    T: Clone,             // 约束：T必须可克隆，因为要将符合条件的元素复制到新集合
    F: FnMut(&T) -> bool, // 约束：闭包接收 &T，返回 bool
{
    let mut result = Vec::new();
    for item in collection {
        if predicate(item) {
            result.push(item.clone()); // 克隆元素，存入结果集合
        }
    }
    result
}

fn main() {
    // 过滤 i32 类型集合：保留偶数
    let nums = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let even_nums = filter(&nums, |&x| x % 2 == 0);
    println!("偶数集合：{:?}", even_nums); // 输出：[2, 4, 6, 8]

    // 过滤 String 类型集合：保留长度大于3的字符串
    let strs = vec![
        String::from("rust"),
        String::from("go"),
        String::from("java"),
        String::from("c++"),
        String::from("python"),
    ];
    let long_strs = filter(&strs, |s| s.len() > 3);
    println!("长度大于3的字符串：{:?}", long_strs); // ["rust", "java", "python"]

    // 过滤自定义结构体集合：保留年龄大于18的用户
    #[derive(Clone, Debug)]
    struct User {
        name: String,
        age: u8,
    }

    let users = vec![
        User {
            name: "张三".to_string(),
            age: 17,
        },
        User {
            name: "李四".to_string(),
            age: 20,
        },
        User {
            name: "王五".to_string(),
            age: 25,
        },
        User {
            name: "赵六".to_string(),
            age: 16,
        },
    ];
    let adult_users = filter(&users, |user| user.age > 18);
    println!("成年用户：{:?}", adult_users); // [User { name: "李四", age: 20 }, User { name: "王五", age: 25 }]
}

总结

掌握泛型后，你可以编写更通用、更安全、更易维护的 Rust 代码，尤其是在开发通用库、数据结构时，泛型都是不可或缺的工具。建议多动手实践，多尝试用泛型重构自己的代码。