走进 Rust：泛型

函数中使用泛型

fn test<T>(t: T) -> T{
    t
}

结构体中使用泛型

单个参数

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

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

多个参数

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

枚举中使用泛型

系统自带枚举Option

enum Option<T> {
    Some(T),
    None,
}

系统自带枚举Result

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

方法中使用泛型

单个参数

x为泛型方法，distance_from_origin只能为float32类型的使用。

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 p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());

    let p2 = Point { x: 500.0, y: 100.0 };

    println!("p2.x = {}", p2.x());
    println!("p2.distance_from_origin = {}", p2.distance_from_origin());

}

多个参数

方法中的参数类型与结构体的泛型类型可以不一致。例子中的结构体类型是T,U而方法中需要的参数的类型为V,W，返回另外一个不同类型T,W的结构体。

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);
}