Rust泛型(Generics)

函数中定义泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
fn largest<T>(list: &[T]) -> &T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

简单来说，定义函数largest具有泛型类型，其参数为类型为T的切片slice，返回值类型为T。

因此，在调用largest时，可以使用任何类型的切片slice，返回与参数相同类型的结果。

结构体中定义泛型

1
2
3
4
5
6
7
8
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

看上面这个例子，在结构体Point中我们只定义了一个类型，这证明Point中的属性可以为泛型，但是x,y必须是相同类型，所以以上的代码时错误的，那么怎么解决呢，继续看下面：

1
2
3
4
5
6
7
8
9
10
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 };
}

我们可以在结构体Point中定义更多的泛型去供更多的想要不同类型的字段使用。

枚举中定义泛型

1
2
3
4
5
6
7
8
enum Option<T> {
    Some(T),
    None,
}
enum Result<T, E> {
    Ok(T),
    Err(E),
}

这个没什么好说的，和结构体中的差不多。

方法中定义泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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);
}

<T,U>型的p1调用了mixup参数为<V,W>型的p2，mixup返回值为<T,W>