Rust 泛型与特性（建议收藏）

Rust 泛型与特性：让代码更通用、更安全

在学习 Rust 的过程中，你可能会遇到这样一个问题：如何写一段代码，让它既能处理整数，又能处理浮点数，甚至还能处理自定义类型？如果为每种类型都写一遍函数，显然效率低下，也违背了 DRY（Don't Repeat Yourself）原则。这时候，Rust 的泛型与特性（Traits）就派上用场了。

泛型与特性是 Rust 类型系统中非常核心的概念，它们不仅让代码更灵活，还保证了运行时性能。今天，我们就来深入浅出地聊聊 Rust 泛型与特性，帮助你从初学者进阶到能写出优雅、安全、可复用代码的中级开发者。

什么是泛型？让类型“延迟决定”

在编程中，我们经常需要写一些通用的函数或数据结构。比如一个交换两个值的函数，你希望它能适用于 i32、f64，甚至是自定义结构体。如果不使用泛型，你就得为每种类型写一个版本：

fn swap_i32(a: i32, b: i32) -> (i32, i32) {
    (b, a)
}

fn swap_f64(a: f64, b: f64) -> (f64, f64) {
    (b, a)
}

这显然很麻烦。而泛型的出现，就是为了解决这种“重复代码”的问题。

泛型允许我们在定义函数或结构体时，暂时不指定具体的类型，而是用一个占位符（比如 T）代替，等到调用时再确定具体类型。

fn swap<T>(a: T, b: T) -> (T, T) {
    (b, a)
}

这里的 T 是一个类型参数，代表“任意类型”。当我们调用这个函数时，Rust 会根据传入的参数自动推导出 T 的具体类型。

fn main() {
    let (x, y) = swap(10, 20);      // T 是 i32
    let (a, b) = swap(3.14, 2.71);  // T 是 f64
    println!("{} {}", x, y);       // 输出: 20 10
    println!("{} {}", a, b);       // 输出: 2.71 3.14
}

小贴士：泛型的本质是“代码复用”，但它不是运行时的动态类型，而是在编译时通过类型推导生成具体代码。这保证了性能不打折扣。

特性（Traits）：定义“能力”的接口

泛型让我们可以处理任意类型，但有时我们希望这些类型“具备某种能力”。比如，我们想比较两个值是否相等，但并不是所有类型都支持 == 操作。

这时，Rust 的特性（Traits）就登场了。你可以把 Traits 理解为“接口”或“能力契约”——它定义了一组方法，哪些类型实现了这个 Traits，就说明它具备了这些能力。

比如，PartialEq 是一个表示“可以比较是否相等”的 Traits：

// 定义一个结构体
struct Point {
    x: i32,
    y: i32,
}

// 让 Point 实现 PartialEq
impl PartialEq for Point {
    fn eq(&self, other: &Self) -> bool {
        self.x == other.x && self.y == other.y
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    let p3 = Point { x: 3, y: 4 };

    println!("{}", p1 == p2); // true
    println!("{}", p1 == p3); // false
}

关键点：impl PartialEq for Point 表示“Point 类型具备与其它 Point 比较的能力”。这个能力是通过实现 eq 方法来完成的。

泛型 + 特性：让代码既通用又安全

现在我们结合泛型和特性，来写一个更实用的例子：写一个函数，判断两个泛型值是否相等。

// 使用 where 子句约束泛型类型必须实现 PartialEq
fn are_equal<T: PartialEq>(a: T, b: T) -> bool {
    a == b
}

fn main() {
    println!("{}", are_equal(5, 5));           // true
    println!("{}", are_equal(3.14, 3.14));     // true
    println!("{}", are_equal("hello", "world")); // false

    // 如果类型不支持 PartialEq，编译会报错
    // let p = Point { x: 1, y: 2 };
    // let p2 = Point { x: 1, y: 2 };
    // println!("{}", are_equal(p, p2)); // ❌ 编译失败！
}

重要说明：T: PartialEq 是一个类型约束，意思是“T 必须实现 PartialEq 特性”。如果没有这个约束，Rust 编译器无法确认 a == b 是否合法。

常见 Traits 实战：From、Into、Display

Rust 标准库中有很多常用 Traits，掌握它们能让你的代码更简洁。

From 与 Into：类型转换的桥梁

From 和 Into 是一对互为反向的 Traits。From 用于“从 A 转换到 B”，而 Into 是“从 B 转换到 A”的语法糖。

// 实现 From 将 i32 转为 String
impl From<i32> for String {
    fn from(value: i32) -> Self {
        value.to_string()
    }
}

fn main() {
    let num: i32 = 42;
    let s: String = num.into();  // 自动调用 From<i32>::from
    println!("{}", s);           // 输出: 42
}

小技巧：如果你实现了 From<A>，Rust 会自动为你生成 Into<A>，所以通常只需实现 From 即可。

Display：格式化输出

Display 用于控制如何将类型转换为字符串，常用于 println!。

use std::fmt;

struct Person {
    name: String,
    age: u8,
}

impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} ({} 岁)", self.name, self.age)
    }
}

fn main() {
    let p = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{}", p); // 输出: Alice (30 岁)
}

注意：fmt::Display 要求实现 fmt 方法，该方法接收一个 Formatter，并返回 fmt::Result。

泛型与特性结合使用：一个完整案例

我们来写一个通用的“容器”类型，支持存储任意可比较的元素，并提供查找功能。

// 定义一个结构体，存储一组可比较的元素
struct Container<T>
where
    T: PartialEq,
{
    items: Vec<T>,
}

impl<T> Container<T>
where
    T: PartialEq,
{
    // 添加元素
    fn add(&mut self, item: T) {
        self.items.push(item);
    }

    // 查找是否包含某个元素
    fn contains(&self, item: &T) -> bool {
        self.items.iter().any(|x| x == item)
    }
}

fn main() {
    let mut container = Container { items: vec![] };

    container.add(10);
    container.add(20);
    container.add(30);

    println!("{}", container.contains(&15)); // false
    println!("{}", container.contains(&20)); // true
}

亮点：我们通过 where T: PartialEq 约束了泛型类型必须能比较，这样 contains 函数才能安全使用 ==。

泛型与特性的优势：性能 + 安全 + 可读性

Rust 泛型与特性之所以强大，是因为它们在不牺牲性能的前提下，提供了极强的抽象能力。

• 性能：Rust 在编译时为每种具体类型生成独立的代码（即“单态化”），所以泛型不会带来运行时开销。
• 安全：通过 Traits 约束，编译器在编译阶段就能发现类型不匹配的问题，避免运行时崩溃。
• 可读性：代码更简洁，逻辑更清晰，开发者更容易理解“这个函数能处理什么类型”。

总结：掌握泛型与特性，是进阶 Rust 的必经之路

Rust 泛型与特性是 Rust 类型系统的核心支柱。它们不仅让代码更加通用和可复用，还保证了类型安全和高性能。

通过今天的学习，你应该已经掌握了：

• 如何使用泛型定义通用函数和结构体；
• 如何通过 Traits 定义类型的能力；
• 如何结合泛型与 Traits 实现安全、灵活的代码；
• 常用 Traits（PartialEq、From、Display）的实际用法。

如果你刚开始接触 Rust，不要害怕这些概念。它们像乐高积木一样，可以组合出复杂而稳定的系统。多写几遍代码，你就会发现：原来泛型与特性是如此优雅、如此强大。

最后，别忘了：真正掌握一门语言，不在于背多少语法，而在于你能用它写出既安全又高效、既简洁又可维护的代码。

Rust 泛型与特性，就是通往这一目标的钥匙。