Rust 的泛型（Generics）允许编写可复用的代码，通过抽象类型或行为来避免重复逻辑。

1. 泛型的基本使用

函数泛型

在函数中定义泛型参数，支持不同类型的数据操作：

fn max<T: PartialOrd>(a: T, b: T) -> T {if a > b { a } else { b }
}fn main() {let largest_number = max(3, 5);println!("The largest number is {}", largest_number);let largest_string = max("apple", "banana");println!("The largest string is {}", largest_string);
}

在这个例子中，max 函数使用了泛型参数 T，并且指定了 T 必须实现 PartialOrd trait，这样才能使用大于操作符 >。

结构体泛型

结构体的字段可以使用泛型类型：

struct Point<T> {x: T,y: T,
}fn main() {let integer_point = Point { x: 5, y: 10 };let float_point = Point { x: 1.2, y: 4.5 };println!("Integer point: ({}, {})", integer_point.x, integer_point.y);println!("Float point: ({}, {})", float_point.x, float_point.y);
}

枚举泛型

Rust 标准库中的 Option<T> 和 Result<T, E> 是经典的泛型枚举：

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

2.方法中的泛型

为泛型结构体实现方法：

impl<T> Point<T> {fn new(x: T, y: T) -> Self {Point { x, y }}
}// 为特定类型实现方法（如 f32）
impl Point<f32> {fn distance_from_origin(&self) -> f32 {(self.x.powi(2) + self.y.powi(2)).sqrt()}
}

3.常见应用场景
集合类型（如 Vec<T>、HashMap<K, V>）。
错误处理（Result<T, E>）。
函数式编程（闭包、迭代器适配器）。
多态 API（如 Web 框架的路由处理）。

4.注意事项
避免过度泛型化：仅在需要抽象不同类型时使用泛型。
命名规范：通常使用 T、U、K、V 等单字母命名泛型参数。
结合 Trait 使用：通过 Trait 约束明确泛型的行为(后面详讲)。

5.改写栈

struct MyStack<T> {queue: Vec<T>, }impl <T> MyStack<T> {fn new() -> Self {return MyStack {queue: Vec::new()};}fn push(&mut self, x: T) {self.queue.push(x);}fn pop(&mut self) -> T {self.queue.pop().expect("Stack is empty")}fn top(&self) -> &T {self.queue.last().expect("Stack is empty")}fn empty(&self) -> bool {return  self.queue.is_empty();}
}
fn main() {let mut num: MyStack<i32> = MyStack::new();num.push(5);num.push(6);let ret_1: i32 = num.pop();println!("{}", ret_1);let ret_2: i32 = num.pop();println!("{}", ret_2);let mut s1: MyStack<String> = MyStack::new();s1.push(String::from("rust"));s1.push(String::from("python"));let ret_3 = s1.pop();println!("{}", ret_3);let ret_4  = s1.pop();println!("{}", ret_4);}

top返回是引用&T，如果一定要返回T,需用Clone克隆

fn top(&mut self) -> T
whereT: Clone, // 添加 Clone 约束
{let n = self.pop();let cloned = n.clone();self.push(n);cloned
}

总结

泛型是编写灵活且可重用代码的强大工具。它们使得你可以编写适用于多种类型的代码，而不需要重复自己。Rust 的泛型系统不仅强大而且非常高效，因为所有泛型代码都在编译时被具体化，确保运行时性能不会受到影响。通过合理地使用泛型，你可以创建出更加通用、类型安全的程序。