【Rust泛型】Rust泛型使用详解与应用场景

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Rust开发，Python全栈，Golang开发，云原生开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Rust语言通关之路
景天的主页：景天科技苑

Rust泛型

泛型用于通常我们放置类型的位置，比如函数签名或结构体，允许我们创建可以代替许多具体数据类型的结构体定义。

1. 泛型的基本概念

1.1 什么是泛型

泛型（Generics）是一种编程语言特性，允许在编写代码时使用类型参数，这些参数可以在使用时被具体类型替换。Rust的泛型系统既强大又安全，能够在编译时检查所有类型约束。
泛型是一种参数化多态的形式，它允许你在定义函数、结构体、枚举和方法时使用类型参数，而不是具体的类型。

// 一个简单的泛型函数示例
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

这里的<T>就是类型参数，表示这个函数可以处理任何类型T。

1.2 为什么使用泛型

代码复用：编写一次算法或数据结构，可适用于多种类型
类型安全：编译器会检查所有类型约束，避免运行时类型错误
性能：Rust的泛型是零成本抽象，编译后会生成特定类型的代码，无运行时开销
表达能力：可以精确表达接口要求和类型关系

2. 泛型函数

2.1 基本语法

泛型函数在函数名后的尖括号中声明类型参数：
声明泛型函数的时候，可以对泛型类型进行约束，T的后面加冒号，后面跟泛型约束特征，多种约束用+ 相连。满足约束特征的参数类型才能使用该泛型函数
比如在求最大值的泛型函数中，如果参数不满足比较的特征，就无法求出最大值

fn identity<T>(x: T) -> T {
    x
}

2.2 实际案例：数据转换函数

假设我们需要一个函数，可以将各种类型转换为字符串：
T的冒号后面，是对泛型的约束，要求泛型满足的条件，ToString，就是满足可以转换成字符串的约束。满足特征的参数类型才能使用该泛型函数

fn to_string<T: ToString>(value: T) -> String {
    value.to_string()
}
fn main() {
    println!("{}", to_string(42)); // "42"
    println!("{}", to_string(3.14)); // "3.14"
    println!("{}", to_string("hello")); // "hello"
}

2.3 使用泛型函数求最大值

//使用泛型函数，求最大值
fn largest<T: PartialOrd + Copy>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        // 使用 PartialOrd trait 来比较元素
        if item > largest {
            // 更新最大值
            // 使用 Copy trait 来复制元素
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 1000, 65, 969];
    let result = largest(&number_list);
    println!("The largest number is: {}", result);

    let char_list = vec!['y', 'm', 'a', 'q', 'z', 'x', '景'];
    let result = largest(&char_list);
    println!("The largest char is: {}", result);
    // println!(char(result));
    let code = *result as u32;
    println!("最大字符的unicode值是: {}", code);
    //将字符转换为unicode值 '字符' as u32
    let zcode = 'z' as u32;
    println!("字符z的unicode值是: {}", zcode);
}

2.4 多类型参数

函数可以接受多个泛型参数：

//多类型参数
fn pair<T, U>(first: T, second: U) -> (T, U) {
    (first, second)
}

fn main() {
    let p = pair(1, "hello");
    println!("p = {:?}", p);
}

3. 泛型结构体和泛型方法

3.1 定义泛型结构体

结构体可以使用一个或多个泛型参数：

// 泛型
// 泛型是 Rust 中的一种强大特性，它允许我们编写可以处理多种数据类型的代码。
#[derive(Debug)]
// 泛型结构体
// 允许我们定义一个结构体，它的字段可以是不同类型的
// 允许定义结构体，不使用字段
#[allow(dead_code)]
struct Pair<T, U> {
    first: T,
    second: U,
}
//泛型方法
impl<T, U> Pair<T, U> {
    fn new(first: T, second: U) -> Self {
        Pair { first, second }
    }
    //方法
    fn first(&self) -> &T {
        &self.first
    }
    fn second(&self) -> &U {
        &self.second
    }

    //混合类型
    fn create_pair<V, W>(self, other: Pair<V, W>) -> Pair<T, W> {
        Pair {
            first: self.first,
            second: other.second,
        }
    }
}


fn main() {
    // 泛型结构体
    let p1 = Pair::new(1, "hello");
    println!("p1 = {:?}", p1);

    let p2 = Pair::new(1.0, 2.0);
    println!("p2 = {:?}", p2);

    let p3 = Pair::new("hello", vec![1, 2, 3]);
    println!("p3 = {:?}", p3);
    // 调用泛型方法
    println!("First element of p1: {:?}", p1.first());
    println!("First element of p2: {:?}", p2.first());
    println!("First element of p3: {:?}", p3.first());
    println!("Second element of p1: {:?}", p1.second());
    println!("Second element of p2: {:?}", p2.second());
    println!("Second element of p3: {:?}", p3.second());

    let p4 = p2.create_pair(p3);
    println!("p4 = {:?}", p4);

}

注意必须在 impl 后面声明 T，U ，这样就可以在 Pair<T, U> 上实现的方法中使用它了。
在 impl 之后声明泛型 T , U，这样Rust 就知道 Point 的尖括号中的类型是泛型而不是具体类型。

泛型不能随便使用解引用
通常是因为你尝试对一个泛型 T 使用解引用操作（*），但 Rust 编译器无法确定 T 是否可以被解引用。
如果非要解引用，必须实现Deref trait
Rust 要求类型必须实现 Deref trait（或是指针类型，如 &T、Box 等）才能使用 * 解引用。如果你在泛型函数或结构体中直接尝试 *t（其中 t: T），但 T 没有约束，就会报这个错误。
type T cannot be dereferenced

解决方案

1. 约束 T 必须实现 Deref
   使用 Deref trait 约束 T，这样 *t 才能合法使用：

use std::ops::Deref;

fn print_value<T: Deref>(t: T) {
    println!("{}", *t); // ✅ 现在 T 必须实现 Deref
}

fn main() {
    let x = 5;
    print_value(&x); // &i32 实现了 Deref，所以可以解引用
}

或者使用 where 语法：

use std::ops::Deref;

fn print_value<T>(t: T)
where
    T: Deref,
    T::Target: std::fmt::Display, // 确保解引用后的值能打印
{
    println!("{}", *t);
}

2. 明确要求 T 是引用类型
   如果你希望 T 必须是一个引用（如 &i32），可以这样写：

fn print_value<T>(t: &T) // 直接接受引用
where
    T: std::fmt::Display,
{
    println!("{}", t); // 不需要解引用，直接打印
}

fn main() {
    let x = 5;
    print_value(&x); // ✅
}

3.2 实际案例：通用数据容器

实现一个可以存储任何类型的容器：

//泛型结构体
struct Container<T> {
    value: T,
}

//泛型方法
impl<T> Container<T> {
    //关联函数
    fn new(value: T) -> Self {
        Self { value }
    }

    //方法
    // 这里的 &self 是一个引用，表示我们在方法中使用的是结构体的实例
    // 这里的 &T 是一个引用，表示我们返回的是一个对 value 的引用
    // 这里的 T 是一个泛型类型，表示我们可以使用任何类型
    fn get_value(&self) -> &T {
        &self.value
    }
}

fn main() {
    let c = Container::new(42);
    println!("{}", c.get_value()); // 42

    let s = Container::new("hello");
    println!("{}", s.get_value()); // hello

    let f = Container::new(3.14);
    println!("{}", f.get_value()); // 3.14

    let v = Container::new(vec![1, 2, 3]);
    println!("{:?}", v.get_value()); // [1, 2, 3]
}

4. 泛型枚举

Rust的标准库中有许多使用泛型的枚举，最著名的就是Option和Result：

//泛型枚举
enum Option<T> {
    Some(T),
    None,
}

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

fn main() {
    // 使用泛型枚举的Some和Ok
    let x: Option<i32> = Option::Some(5);
    let y: Result<i32, String> = Result::Ok(10);

    match x {
        Option::Some(value) => println!("Option has value: {}", value),
        Option::None => println!("Option is None"),
    }

    match y {
        Result::Ok(value) => println!("Result is Ok with value: {}", value),
        Result::Err(err) => println!("Result is Err with error: {}", err),
    }

    // 使用泛型枚举的None和Err
    let z: Option<i32> = Option::None;
    match z {
        Option::Some(value) => println!("Option has value: {}", value),
        Option::None => println!("Option is None"),
    }
    let w: Result<i32, String> = Result::Err("An error occurred".to_string());
    match w {
        Result::Ok(value) => println!("Result is Ok with value: {}", value),
        Result::Err(err) => println!("Result is Err with error: {}", err),
    }
}

5. 特征约束（Trait Bounds）

声明泛型函数的时候，可以对泛型类型进行约束，T的后面加冒号，后面跟泛型约束特征，多种约束用+ 相连。满足约束特征的参数类型才能使用该泛型函数

5.1 基本特征约束

符合特征约束的参数，才能成功调用该函数

fn print_debug<T: std::fmt::Debug>(value: T) {
    println!("{:?}", value);
}

5.2 多重约束

使用+符号指定多个特征约束：

fn clone_and_print<T: Clone + std::fmt::Debug>(value: T) {
    let cloned = value.clone();
    println!("{:?}", cloned);
}

5.3 where子句

一般的约束，只需要在T后面的冒号后加上约束即可，对于复杂的约束，可以使用where子句提高可读性：

//where子句
fn complex_function<T, U>(t: T, u: U) -> i32
    where T: std::fmt::Display + Clone, U: Clone + std::fmt::Debug
{
    // 函数实现
    println!("t = {}", t);
    println!("u = {:?}", u);
    // 返回一个整数
    42
}

6. 泛型的性能

6.1 零成本抽象

Rust 实现泛型的方式意味着你的代码使用泛型类型参数，相比指定具体类型并没有任何速度上的损失！
Rust 通过在编译时进行泛型代码的 单态化（monomorphization）来保证效率。
单态化是一个将泛型代码转变为实际放入的具体类型的特定代码的过程。

这意味着：
运行时没有类型检查开销
生成的代码与手写特定类型代码一样高效
但可能导致代码膨胀（更大的二进制文件）

让我们看看一个使用标准库中 Option 枚举的例子：

let integer = Some(5);
let float = Some(5.0);

当 Rust 编译这些代码的时候，它会进行单态化。编译器会读取传递给 Option 的值并发现有两种 Option<T> ：一个对应i32 另一个对应 f64 。
为此，它会将泛型定义 Option 展开为 Option_i32 和 Option_f64 ，接着将泛型定义替换为这两个具体的定义。

6.2 何时使用泛型

算法需要在多种类型上工作：如排序、搜索等
数据结构需要存储不同类型：如Vec、Option等
需要类型安全的多态行为：避免使用dyn trait带来的运行时开销

6.3 何时避免泛型

只有少数具体类型：可能不值得增加复杂性
性能不是关键因素：可以考虑使用trait对象
导致过于复杂的类型签名：可能影响代码可读性