Rust 泛型与特性学习笔记

1. 泛型基础

Rust 提供了泛型编程的支持，可以写出更加通用、灵活的代码。泛型可以在代码中使用相同的逻辑处理不同类型的数据。

1.1 定义泛型类型

定义泛型类型需要使用 <T> 语法，其中 T 是一个占位符，代表任意类型。

rustCopy Code
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 10, y: 20 };
    let float_point = Point { x: 10.0, y: 20.0 };
}

1.2 定义泛型函数

定义泛型函数也需要使用 <T> 语法。

rustCopy Code
fn get_larger<T: PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

fn main() {
    let larger_integer = get_larger(10, 20);
    let larger_float = get_larger(10.0, 20.0);
}

T: PartialOrd 表示 T 类型必须实现 PartialOrd trait。

2. 特性基础

Rust 的特性是一种声明式接口，可以用于约束泛型类型。

2.1 定义特性

定义特性需要使用 trait 关键字。

rustCopy Code
trait Draw {
    fn draw(&self);
}

2.2 实现特性

实现特性需要使用 impl 关键字。

rustCopy Code
struct Shape {
    x: i32,
    y: i32,
}

impl Draw for Shape {
    fn draw(&self) {
        println!("Shape at ({}, {})", self.x, self.y);
    }
}

fn main() {
    let shape = Shape { x: 10, y: 20 };
    shape.draw();
}

3. 泛型与特性的结合使用

泛型和特性经常会结合在一起使用，以实现更加通用、灵活的功能。

3.1 定义泛型类型约束特性

rustCopy Code
struct Screen<T: Draw> {
    components: Vec<T>,
}

impl<T> Screen<T>
where
    T: Draw,
{
    fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
} 

fn main() {
    let screen = Screen {
        components: vec![
            Shape { x: 10, y: 20 },
            Shape { x: 30, y: 40 },
        ],
    };
    screen.run();
}

3.2 定义泛型函数约束特性

rustCopy Code
fn draw_and_get_larger<T: Draw + PartialOrd>(a: T, b: T) -> T {
    a.draw();
    b.draw();

    if a > b {
        a
    } else {
        b
    }
}

fn main() {
    let larger_shape = draw_and_get_larger(
        Shape { x: 10, y: 20 },
        Shape { x: 30, y: 40 },
    );
}

T: Draw + PartialOrd 表示 T 类型必须实现 Draw 特性和 PartialOrd trait。