Rust 泛型：<T> 类型参数与 trait 约束

Rust 泛型：<T> 类型参数与 trait 约束

在 Rust 中编写代码时，经常需要处理多种不同类型的数据，但逻辑却完全一致。泛型允许你定义一套逻辑，使其适用于各种具体类型，从而避免代码重复。本文将详细介绍如何定义类型参数 <T> 以及如何使用 trait 约束来限制泛型的行为。

1. 理解类型参数 <T>

类型参数是泛型的核心，它通常用大写字母表示（如 T），代表一个“待定”的具体类型。编译器会在后续使用代码时，将 T 替换为实际的类型（如 i32、String）。

定义一个泛型函数时，必须在函数名后的尖括号中声明参数 T。

编写以下代码，定义一个接收任意类型切片并返回其中最大值的函数：

fn largest(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

尝试编译上述代码，编译器会报错。这是因为 T 可以是任何类型，编译器并不知道如何对 T 执行 > 运算操作，也不知道如何拷贝返回值。

2. 添加 trait 约束

为了让代码工作，必须告诉编译器 T 具备哪些能力。在 Rust 中，能力被称为 trait。你需要使用 : 语法来为 T 添加约束。

修改上面的函数签名，要求 T 必须实现 PartialOrd trait（用于比较大小）和 Copy trait（允许从引用中拷贝值）：

fn largest(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

观察代码，T: PartialOrd + Copy 的含义是：T 必须同时满足这两个 trait。这样编译器就知道可以对 item 进行比较并赋值了。

3. 在结构体和枚举中使用泛型

泛型同样适用于结构体和枚举定义。

定义一个存放两个不同类型值的结构体 Point：

struct Point {
    x: T,
    y: U,
}

实例化该结构体时，指定具体的类型：

let both_integer = Point { x: 5, y: 10 };
let both_float = Point { x: 1.0, y: 4.0 };
let integer_and_float = Point { x: 5, y: 4.0 };

定义一个枚举，例如标准库中的 Option 或 Result 也是典型的泛型应用：

enum Result {
    Ok(T),
    Err(E),
}

4. 使用 where 子句简化约束

当泛型约束变得很长、很复杂时，直接写在函数签名后会影响可读性。Rust 提供了 where 子句将约束移到函数体之前。

对比以下两种写法。这是不使用 where 的写法：

fn some_function(t: &T, u: &U) -> i32 
where 
    T: Display + Clone,
    U: Clone + Debug,
{
    // ...
}

这是不使用 where 的写法（不推荐用于复杂场景）：

fn some_function(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{
    // ...
}

在实际开发中，使用 where 子句能让函数签名更清晰，便于快速查看函数名和参数列表。

5. 泛型代码执行的逻辑流程

为了理解 Rust 编译器如何处理泛型，可以参考以下处理流程。编译器会在编译阶段进行“单态化”，即为每个具体类型生成对应的机器码。

通过单态化，Rust 的泛型在运行时没有任何性能开销，与手动编写针对特定类型的代码效率完全一致。

常用 Trait 约束速查表

下表列出了开发中最常用的 trait 约束及其含义。

6. 实战演练：构建带约束的泛型函数

创建一个新的 Rust 项目或直接在 main.rs 中输入以下完整示例。这个函数接受两个实现了 Display trait 的参数，并打印它们。

1. 定义函数 print_pair，使用 where 子句约束 T 和 U。
2. 实现打印逻辑。

use std::fmt::Display;

fn print_pair(t: &T, u: &U)
where
    T: Display + ?Sized,
    U: Display + ?Sized,
{
    println!("Display: t = {}, u = {}", t, u);
}

fn main() {
    let number = 10;
    let text = "Hello";

    // 调用泛型函数
    print_pair(&number, text);
}

运行程序，终端将输出：

Display: t = 10, u = Hello

在这个例子中，?Sized 是一个特殊的约束，表示类型可以是动态大小类型（DST，如 str 切片），这通常用于引用类型 &T。这允许我们将字符串字面量直接传递给函数。

掌握了 <T> 的声明与 trait 约束，即可在保证类型安全的同时，编写出高复用率的 Rust 代码。