当前位置：首页 > news >正文

Rust泛型编程实战

news 2026/7/6 19:36:36

Rust泛型编程实战

后端转 Rust 的萌新，ID "第一程序员"——名字大，人很菜（暂时）。正在跟所有权和生命周期死磕，日常记录 Rust 学习路上的踩坑经验和"啊哈时刻"，代码片段保证能跑。保持学习，保持输出。欢迎大佬们轻喷，也欢迎同好一起进步。

前言

最近在学习 Rust 的过程中，我开始关注泛型编程。作为一个从后端转 Rust 的萌新，我认为了解 Rust 的泛型编程是非常有必要的，它可以帮助我们编写更加灵活、可重用的代码。

Rust 的泛型系统非常强大，它允许我们编写与具体类型无关的代码，同时保持类型安全。今天，我就来分享一下 Rust 泛型编程的相关知识和实战经验，希望能帮到和我一样的萌新们。

泛型的基本概念

什么是泛型

泛型是一种编程范式，它允许我们编写与具体类型无关的代码，在使用时再指定具体的类型。

泛型的优势

代码重用：可以编写一次代码，用于多种类型
类型安全：在编译时进行类型检查，避免运行时错误
性能优化：编译器会为每种具体类型生成专门的代码，不会有运行时开销
灵活性：可以编写更加通用的函数和数据结构

泛型的基本使用

泛型函数

fn largest<T: PartialOrd>(list: &[T]) -> &T { let mut largest = &list[0]; for item in list { if item > largest { largest = item; } } largest } fn main() { let numbers = vec![34, 50, 25, 100, 65]; let result = largest(&numbers); println!("The largest number is {}", result); let chars = vec!['y', 'm', 'a', 'q']; let result = largest(&chars); println!("The largest char is {}", result); }

泛型结构体

struct Point<T> { x: T, y: T, } impl<T> Point<T> { fn x(&self) -> &T { &self.x } } impl Point<f32> { fn distance_from_origin(&self) -> f32 { (self.x.powi(2) + self.y.powi(2)).sqrt() } } fn main() { let integer = Point { x: 5, y: 10 }; let float = Point { x: 1.0, y: 4.0 }; println!("integer.x = {}", integer.x()); println!("float.x = {}", float.x()); println!("float distance = {}", float.distance_from_origin()); }

泛型枚举

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

泛型约束

特征约束

fn print<T: Debug>(item: T) { println!("{:?}", item); } fn main() { print(5); print("hello"); print([1, 2, 3]); }

多个约束

fn compare_and_print<T: Debug + PartialOrd>(a: T, b: T) { if a > b { println!("{:?} is greater than {:?}", a, b); } else if a < b { println!("{:?} is less than {:?}", a, b); } else { println!("{:?} is equal to {:?}", a, b); } } fn main() { compare_and_print(5, 10); compare_and_print("apple", "banana"); }

where 子句

fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug, { // 函数体 42 }

实战案例：实现一个通用的栈

struct Stack<T> { items: Vec<T>, } impl<T> Stack<T> { fn new() -> Self { Stack { items: Vec::new() } } fn push(&mut self, item: T) { self.items.push(item); } fn pop(&mut self) -> Option<T> { self.items.pop() } fn peek(&self) -> Option<&T> { self.items.last() } fn is_empty(&self) -> bool { self.items.is_empty() } fn size(&self) -> usize { self.items.len() } } fn main() { // 整数栈 let mut int_stack = Stack::new(); int_stack.push(1); int_stack.push(2); int_stack.push(3); println!("Int stack size: {}", int_stack.size()); println!("Int stack peek: {:?}", int_stack.peek()); while let Some(item) = int_stack.pop() { println!("Popped: {}", item); } // 字符串栈 let mut string_stack = Stack::new(); string_stack.push("hello"); string_stack.push("world"); println!("\nString stack size: {}", string_stack.size()); println!("String stack peek: {:?}", string_stack.peek()); while let Some(item) = string_stack.pop() { println!("Popped: {}", item); } }

泛型的高级使用

泛型方法

struct Point<T, U> { x: T, y: U, } impl<T, U> Point<T, U> { fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> { Point { x: self.x, y: other.y, } } } fn main() { let p1 = Point { x: 5, y: 10.4 }; let p2 = Point { x: "Hello", y: 'c' }; let p3 = p1.mixup(p2); println!("p3.x = {}, p3.y = {}", p3.x, p3.y); }

关联类型

trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>; } struct Counter { count: u32, } impl Iterator for Counter { type Item = u32; fn next(&mut self) -> Option<Self::Item> { if self.count < 5 { self.count += 1; Some(self.count) } else { None } } } fn main() { let mut counter = Counter { count: 0 }; while let Some(value) = counter.next() { println!("Got: {}", value); } }

泛型类型参数推断

fn identity<T>(x: T) -> T { x } fn main() { let s = identity("hello"); let i = identity(42); let f = identity(3.14); println!("s = {}, i = {}, f = {}", s, i, f); }