文章目录
- [深入浅出 Rust 泛型：从入门到实战](#深入浅出 Rust 泛型：从入门到实战)
-
- 为什么需要泛型？
- 基本用法
- 泛型约束
-
- 简洁约束（冒号语法）
- [where 子句约束](#where 子句约束)
- 泛型进阶：关联类型与默认类型参数
-
- [关联类型（Associated Types）](#关联类型（Associated Types）)
- 默认类型参数
- 实战：用泛型实现通用数据过滤器
- 总结
深入浅出 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 函数，适配所有支持"大于比较"的类型：
rust
fn max<T>(a: T, b: T) -> T
where
T: PartialOrd, // 约束：T 必须实现 PartialOrd 特征，支持比较
{
if a > b { a } else { b }
}基本用法
Rust 泛型可应用于函数、结构体、枚举、方法等多种场景，核心语法是通过 <T> 声明类型参数，再通过 where 子句添加约束。
泛型函数
这里直接举一个简单示例：实现一个通用的打印值的函数，适配任意实现了 Display 特征：
rust
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 特征。
rust
fn print_value<T>(value: T)
where
T: Display,
{
println!("值：{}", value);
}泛型结构体
泛型结构体允许结构体的字段使用类型参数，使结构体能够适配多种类型的字段。例如，实现一个通用的包装器结构体，用于包裹任意类型的值：
rust
// 泛型结构体：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，它们通过泛型适配不同类型的返回值。我们可以自定义一个类似的泛型枚举：
rust
// 泛型枚举：表示"成功"或"失败"，失败时携带错误信息
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
}
}泛型约束
泛型的灵活性需要通过"约束"来限制，否则编译器无法确定类型参数支持哪些操作。
简洁约束（冒号语法）
直接在类型参数后加冒号，指定需要实现的特征，适用于单个约束：
rust
// T 必须实现 Display 和 Clone 两个特征（多个特征用+连接）
fn print_and_clone<T: Display + Clone>(value: T) {
println!("值：{}", value);
// 因为T实现了 Clone，所以可以调用 clone 方法
let cloned = value.clone();
}where 子句约束
当约束较多或逻辑复杂时，使用 where 子句更清晰，适用于多个类型参数、多个约束的场景：
rust
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 特征：
rust
// 标准库中的 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
}
}关联类型与泛型参数的区别：关联类型是特征的一部分，一个特征只能有一个关联类型；而泛型参数是函数/结构体的一部分，可以有多个。关联类型更适合一个特征对应一个核心类型的场景，减少泛型参数的冗余。
默认类型参数
默认类型参数允许为泛型参数指定一个默认值，当使用时不传入具体类型时，就使用默认值。这在需要向后兼容、默认适配常见类型等场景中非常实用。
rust
// 泛型结构体：默认类型为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("默认类型参数"));
}注意：默认类型参数只是默认值，用户可以显式指定其他类型，不会限制泛型的灵活性。
实战：用泛型实现通用数据过滤器
结合前文的泛型约束、闭包用法，我们实现一个通用的数据过滤器，支持对任意类型的集合进行过滤，可通过闭包传入自定义过滤规则，适配不同类型的数据筛选场景，更贴近实际开发需求。
rust
// 泛型过滤函数：接收一个集合和一个过滤闭包，返回符合条件的元素组成的新集合
// 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 代码，尤其是在开发通用库、数据结构时，泛型都是不可或缺的工具。建议多动手实践，多尝试用泛型重构自己的代码。