【Rust 基础入门】(13) | 泛型与特征

泛型

在Rust编程中，我们经常需要编写既灵活又高效的代码。泛型（Generics） 正是为此而生，它允许我们编写适用于多种类型的代码，而无需为每种类型重复劳动。想象你在设计一套家具模板：桌子可以用木头、金属甚至玻璃制作，但设计图本身是通用的，只需在建造时指定材料。泛型也是如此，通过类型参数（如T）定义一个“模板”，在具体使用时填充实际类型。

比如，Rust 标准库中的 Vec<T> 可以存储整数、浮点数或任何类型，而 Option<T> 能包装任意值。这种参数化类型的能力让代码更通用、更简洁，同时保留了 Rust 的类型安全。

从具体到抽象

假设我们要写一个函数，找出数组中的最大值。如果只针对i32类型，代码可能是这样的：

fn max_i32(list: &[i32]) -> i32 {
    let mut max = list[0];
    for &item in list {
        if item > max {
            max = item;
        }
    }
    max
}

现在，如果想支持 f64 类型呢？可以再写一个几乎一模一样的 max_f64 函数，但这显然很浪费。泛型提供了一个优雅的解决方案：

fn max<T>(list: &[T]) -> T {
    let mut max = list[0];
    for &item in list {
        if item > max {  // 注意：这里需要类型约束，后面会解决
            max = item;
        }
    }
    max
}

这里，T 就像家具模板中的“材料”，可以替换成 i32、f64 或任何类型。但有个问题：编译器不知道 T 能不能比较大小（ > 运算符）。这就引出了泛型与特征的关系，稍后我们会解决。

泛型无处不在

泛型不仅能用在函数中，还能灵活地应用于结构体、枚举和方法。看看这些例子：

// 结构体：表示二维坐标
struct Coord<T> {
    x: T,
    y: T,
}

// 带多种类型的结构体
struct Pair<T, U> {
    first: T,
    second: U,
}

// 枚举：表示成功或失败的结果
enum Result<T> {
    Ok(T),
    Err(String),
}

// 方法：为Coord实现获取x坐标的功能
impl<T> Coord<T> {
    fn get_x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let int_coord = Coord { x: 3, y: 4 };
    let float_coord = Coord { x: 1.5, y: 2.5 };
    let pair = Pair { first: 42, second: "hello" };
    let result = Result::Ok(100);

    println!("x: {}", int_coord.get_x());  // 输出: x: 3
}

这些结构就像通用的模具，可以浇铸出不同类型的实例，展示了泛型的强大灵活性。

泛型与特征

泛型虽然强大，但有时需要限制类型的能力。回到前面的 max 函数，T 可以是任何类型，但并非所有类型都能用 > 比较。这时，特征（Traits） 为泛型提供了约束，确保类型具备特定的行为。

单态化

在Rust中，泛型通过 单态化（monomorphization） 实现零成本抽象。编译器会在编译时为每种具体类型生成专属代码。比如：

fn max<T>(list: &[T]) -> T {
    let mut max = list[0];
    for &item in list {
        if item > max {
            max = item;
        }
    }
    max
}

fn main() {
    let ints = [1, 5, 3];
    let floats = [1.2, 0.5, 2.8];
    max(&ints);  // T 被替换为 i32
    max(&floats);  // T 被替换为 f64
}

编译器会为 i32 和 f64 分别生成两个具体函数，类似于手写的 max_i32 和 max_f64 函数。这意味着泛型没有运行时开销，性能与直接编写具体类型一致。

添加特征约束

但上面的 max 函数还不能编译，因为 T 需要支持比较和复制。我们需要借助特征约束。Rust 标准库中的 PartialOrd 特征定义了比较行为（>），Copy 特征允许值的复制。改进后的代码如下：

fn max<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut max = list[0];
    for &item in list {
        if item > max {
            max = item;
        }
    }
    max
}

fn main() {
    let ints = [1, 5, 3];
    let floats = [1.2, 0.5, 2.8];
    println!("Max int: {}", max(&ints));  // 输出: Max int: 5
    println!("Max float: {}", max(&floats));  // 输出: Max float: 2.8
}

• T: PartialOrd 确保T可以比较大小。
• T: Copy 允许 list[0] 被复制到 max，避免所有权问题。

如果约束较多，还可以用 where 子句让代码更清晰：

fn max<T>(list: &[T]) -> T
where
    T: PartialOrd + Copy,
{
    let mut max = list[0];
    for &item in list {
        if item > max {
            max = item;
        }
    }
    max
}

这种搭配就像为家具模板指定要求：不仅要用某种材料，还要确保材料能被切割和拼接。泛型提供结构，特征定义规则，二者结合让代码既通用又安全。

小结

• 泛型（Generics） 通过类型参数定义通用的代码框架，提升复用性和可读性。
• 特征（Traits） 为泛型添加约束，确保类型具备必要的行为。
• 通过单态化，Rust 在编译时生成具体代码，实现零成本抽象。