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 chars = vec!['y', 'm', 'a', 'q'];
    
    println!("最大数字：{}", largest(&numbers));
    println!("最大字符：{}", largest(&chars));
}

泛型结构体

// 通用的点坐标结构体
struct Point<T> {
    x: T,
    y: T,
}

// 混合类型的点
struct MixedPoint<T, U> {
    x: T,
    y: U,
}

fn main() {
    // 整数点
    let integer_point = Point { x: 5, y: 10 };
    
    // 浮点数点
    let float_point = Point { x: 1.0, y: 4.0 };
    
    // 混合类型点
    let mixed_point = MixedPoint { x: 5, y: 4.0 };
}

泛型枚举

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

// Result 枚举的泛型实现
enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {
    let some_number: Option<i32> = Option::Some(5);
    let some_string: Option<String> = Option::Some(String::from("hello"));
}

泛型方法

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// 特定类型的方法
impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

特征（Trait）

特征定义

// 定义特征
trait Summary {
    fn summarize(&self) -> String;
    
    // 带默认实现的方法
    fn default_summary(&self) -> String {
        String::from("阅读更多...")
    }
}

struct NewsArticle {
    headline: String,
    author: String,
}

// 为类型实现特征
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {}", self.headline, self.author)
    }
}

特征约束

// 特征作为参数约束
fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// 多特征约束
fn process<T: Summary + Display>(item: &T) {
    println!("{}", item.summarize());
}

// where 子句简化复杂约束
fn complex_function<T, U>(t: &T, u: &U) 
where 
    T: Summary + Clone,
    U: Display + Debug 
{
    // 函数体
}

特征对象

trait Draw {
    fn draw(&self);
}

struct Button {
    width: u32,
}

struct TextField {
    placeholder: String,
}

impl Draw for Button {
    fn draw(&self) {
        println!("绘制按钮");
    }
}

impl Draw for TextField {
    fn draw(&self) {
        println!("绘制文本框");
    }
}

// 使用特征对象
fn render(components: &[&dyn Draw]) {
    for component in components {
        component.draw();
    }
}

派生特征

// 自动实现常用特征
#[derive(Debug, Clone, PartialEq)]
struct Person {
    name: String,
    age: u32,
}

生命周期

生命周期注解

// 生命周期标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 结构体中的生命周期
struct ImportantExcerpt<'a> {
    part: &'a str,
}

生命周期省略规则

// 编译器自动推断生命周期
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

生命周期约束

// 复杂生命周期约束
fn longest_with_announcement<'a, T>(
    x: &'a str, 
    y: &'a str, 
    ann: T
) -> &'a str 
where 
    T: Display 
{
    println!("公告：{}", ann);
    if x.len() > y.len() { x } else { y }
}

最佳实践

1. 使用泛型减少代码重复
2. 通过特征实现多态
3. 谨慎使用特征对象
4. 理解生命周期的基本规则
5. 优先使用生命周期省略

结语

泛型、特征和生命周期是 Rust 类型系统的核心特性。它们提供了强大的抽象能力，同时保持了编译期的类型安全。深入理解这些概念需要大量实践和思考。