Rust泛型編程深入實例介紹應(yīng)用技巧

更新時間：2026年05月05日 11:11:45 作者：第一程序員

這篇文章主要介紹了Rust泛型編程,泛型是Rust中一種強大的特性,它允許我們編寫通用的代碼,適用于不同類型,通過掌握泛型的高級應(yīng)用,我們可以編寫更加靈活、可復(fù)用的代碼,需要的朋友可以參考下

1. 泛型基礎(chǔ)

泛型是 Rust 中一種強大的特性，它允許我們編寫通用的代碼，適用于不同類型。

// 泛型函數(shù)
fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}
fn main() {
    println!("1 + 2 = {}", add(1, 2));
    println!("1.5 + 2.5 = {}", add(1.5, 2.5));
}

2. 高級泛型技巧

2.1 泛型結(jié)構(gòu)體

// 泛型結(jié)構(gòu)體
struct Point<T> {
    x: T,
    y: T,
}
impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
    fn x(&self) -> &T {
        &self.x
    }
}
// 為特定類型實現(xiàn)方法
impl Point<i32> {
    fn distance_from_origin(&self) -> f64 {
        ((self.x * self.x + self.y * self.y) as f64).sqrt()
    }
}
fn main() {
    let p1 = Point::new(1, 2);
    let p2 = Point::new(1.5, 2.5);
    println!("p1.x = {}", p1.x());
    println!("p2.x = {}", p2.x());
    println!("p1 distance from origin: {}", p1.distance_from_origin());
}

2.2 泛型枚舉

// 泛型枚舉
enum Option<T> {
    Some(T),
    None,
}
enum Result<T, E> {
    Ok(T),
    Err(E),
}
fn main() {
    let some_number = Option::Some(5);
    let some_string = Option::Some("hello");
    let none = Option::None;
    match some_number {
        Option::Some(value) => println!("Value: {}", value),
        Option::None => println!("No value"),
    }
}

2.3 泛型 trait

// 泛型 trait
trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}
// 實現(xiàn)泛型 trait
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!("Value: {}", value);
    }
}

2.4 泛型邊界

// 泛型邊界
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        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);
}

3. 實際應(yīng)用場景

3.1 容器類型

// 泛型容器
struct Stack<T> {
    items: Vec<T>,
}
impl<T> Stack<T> {
    fn new() -> Self {
        Self { items: Vec::new() }
    }
    fn push(&mut self, item: T) {
        self.items.push(item);
    }
    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }
    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }
}
fn main() {
    let mut stack = Stack::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    while !stack.is_empty() {
        println!("Popped: {:?}", stack.pop());
    }
}

3.2 函數(shù)包裝器

// 泛型函數(shù)包裝器
fn with_logging<F, R>(func: F) -> R
where
    F: Fn() -> R,
{
    println!("Before function call");
    let result = func();
    println!("After function call");
    result
}
fn main() {
    let result = with_logging(|| {
        println!("Inside function");
        42
    });
    println!("Result: {}", result);
}

3.3 類型轉(zhuǎn)換

// 泛型類型轉(zhuǎn)換
trait From<T> {
    fn from(value: T) -> Self;
}
trait Into<T> {
    fn into(self) -> T;
}
// 為 String 實現(xiàn) From<&str>
impl From<&str> for String {
    fn from(s: &str) -> Self {
        s.to_string()
    }
}
// 為所有類型實現(xiàn) Into
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U {
        U::from(self)
    }
}
fn main() {
    let s: String = "hello".into();
    println!("String: {}", s);
}

3.4 多態(tài)

// 泛型多態(tài)
trait Draw {
    fn draw(&self);
}
struct Circle {
    radius: f64,
}
struct Rectangle {
    width: f64,
    height: f64,
}
impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius {}", self.radius);
    }
}
impl Draw for Rectangle {
    fn draw(&self) {
        println!("Drawing a rectangle with width {} and height {}", self.width, self.height);
    }
}
// 泛型函數(shù)，接受任何實現(xiàn)了 Draw trait 的類型
fn draw_shape<T: Draw>(shape: T) {
    shape.draw();
}
fn main() {
    let circle = Circle { radius: 5.0 };
    let rectangle = Rectangle { width: 10.0, height: 20.0 };
    draw_shape(circle);
    draw_shape(rectangle);
}