10.1 泛型编程
泛型编程是一种通过参数化的方式编写代码，使其能够处理多种不同类型的数据，而无需重复编写代码。在 Rust 中，泛型是一个重要的特性，它不仅提高了代码的复用性，还能保持强类型系统的安全性。
Rust 中的泛型支持不仅体现在函数和类型定义中，还结合了编译时的零开销抽象（Zero-Cost Abstraction），确保性能不会受到影响。
10.1.1 泛型的基本概念
泛型允许开发者定义可以适应多种类型的代码。通过在类型和函数签名中引入泛型参数，可以使代码更具适应性，同时避免重复。
泛型参数语法
在 Rust 中，泛型参数通常用尖括号（<>）包裹。例如，T 是一个泛型参数，它可以代表任何类型。
1
2
3
|
fn generic_function<T>(value: T) {
println!("Value: {:?}", value);
}
|
这里，T 是一个泛型参数，value 的类型由调用者决定。
10.1.2 函数中的泛型
泛型函数可以接受多种类型的参数，而无需为每种类型单独编写实现。
示例：泛型函数
1
2
3
4
5
6
7
8
9
|
fn display_value<T: std::fmt::Debug>(value: T) {
println!("{:?}", value);
}
fn main() {
display_value(42); // 打印整数
display_value("hello"); // 打印字符串
display_value(vec![1, 2, 3]); // 打印向量
}
|
约束泛型类型
泛型函数中可以对参数类型施加约束。例如，通过特性（trait）约束，可以限制泛型参数必须实现某些行为。
1
2
3
4
5
6
7
8
|
fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
a + b
}
fn main() {
println!("{}", add(5, 10)); // 整数相加
println!("{}", add(2.5, 3.7)); // 浮点数相加
}
|
10.1.3 结构体中的泛型
Rust 允许在结构体定义中使用泛型，使结构体可以存储任意类型的数据。
定义泛型结构体
1
2
3
4
5
6
7
8
9
10
11
12
|
struct Point<T> {
x: T,
y: T,
}
fn main() {
let int_point = Point { x: 5, y: 10 };
let float_point = Point { x: 1.5, y: 3.7 };
println!("Integer Point: ({}, {})", int_point.x, int_point.y);
println!("Float Point: ({}, {})", float_point.x, float_point.y);
}
|
多类型的泛型
结构体还可以支持多个泛型参数，以存储不同类型的数据。
1
2
3
4
5
6
7
8
9
|
struct MixedPoint<T, U> {
x: T,
y: U,
}
fn main() {
let mixed_point = MixedPoint { x: 5, y: 3.7 };
println!("Mixed Point: ({}, {})", mixed_point.x, mixed_point.y);
}
|
10.1.4 枚举中的泛型
枚举也可以包含泛型参数，常见于标准库的 Option 和 Result 类型。
定义泛型枚举
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
enum Option<T> {
Some(T),
None,
}
fn main() {
let some_number = Option::Some(42);
let no_number: Option<i32> = Option::None;
match some_number {
Option::Some(value) => println!("Value: {}", value),
Option::None => println!("No value found."),
}
}
|
10.1.5 方法中的泛型
方法可以在类型定义时使用泛型，也可以单独在方法中声明泛型。
结构体方法中的泛型
1
2
3
4
5
6
7
8
9
10
|
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
|
为特定类型实现方法
可以为某些具体类型定义特定的方法实现。
1
2
3
4
5
|
impl Point<f32> {
fn distance_from_origin(&self) -> f32 {
(self.x.powi(2) + self.y.powi(2)).sqrt()
}
}
|
10.1.6 泛型的性能
Rust 的泛型是零开销的。编译器会在编译时为每种具体类型生成专门的代码（类似于 C++ 的模板机制）。虽然这种方法可能导致代码体积增大，但它确保了泛型代码的运行性能与手写的具体类型代码相同。
示例：编译后的代码行为
1
2
3
|
fn generic_function<T>(value: T) {
// 编译时为每种类型生成专门的实现
}
|
在实际编译时，编译器会为 i32 和 f64 等类型分别生成对应的代码，而不会有运行时的泛型开销。
10.1.7 泛型的最佳实践
- 尽量明确类型约束：为泛型参数添加特性约束，可以提高代码的可读性和可用性。
- 避免过度泛型化：过多的泛型参数可能导致代码复杂度增加，应该根据需求选择合适的泛型设计。
- 结合特性使用：泛型和特性（Traits）是 Rust 的强大组合，通过为泛型添加特性，可以实现更高级的抽象。
10.1.8 小结
- 泛型是 Rust 中的核心特性，用于编写灵活且类型安全的代码。
- 泛型可以用于函数、结构体、枚举和方法，提升代码的复用性。
- Rust 的零开销抽象确保了泛型代码的性能。
- 开发中需平衡泛型的灵活性与代码的可读性，通过特性约束可以增强代码的安全性和功能性。
下一节将深入讨论 Rust 的特性（Traits），以及如何结合泛型实现更强大的抽象能力。