Rust编程进阶：003、在结构体和方法中使用泛型

3、在结构体中使用泛型。

1// 在结构体中使用泛型
2#[derive(Debug)]
3struct Point<T> {
4    x: T,
5    y: T,
6}
7
8#[derive(Debug)]
9struct Point2<T, U> {
10    x: T,
11    y: U,
12}
13
14fn main() {
15    let integer = Point { x: 1, y: 2 };
16    println!("{:#?}", integer);
17
18    let float = Point { x: 1.1, y: 2.2 };
19    println!("{:?}", float);
20
21    let a = Point2 { x: 1.1, y: 'a' };
22    println!("a = {:?}", a);
23}

4、枚举中的泛型。

1// 在枚举中使用泛型
2enum Option<T> {
3    Some(T),
4    None,
5}
6
7enum Result<T, E> {
8    Ok(T),
9    Err(E),
10}

5、方法中的泛型。

1// 在方法中使用泛型
2struct Point<T> {
3    x: T,
4    y: T,
5}
6
7impl<T> Point<T> {
8    fn get_x(&self) -> &T {
9        &self.x
10    }
11
12    fn get_y(&self) -> &T {
13        &self.y
14    }
15}
16
17struct Point2<T, U> {
18    x: T,
19    y: U,
20}
21
22impl<T, U> Point2<T, U> {
23    fn creat_point<V, W>(self, other: Point2<V, W>) -> Point2<T, W> {
24        Point2 {
25            x: self.x,
26            y: other.y,
27        }
28    }
29}
30
31fn main() {
32    let p = Point { x: 1, y: 2 };
33    println!("x = {}", p.get_x());
34    println!("y = {}", p.get_y());
35
36    let p = Point { x: 1.1, y: 2.2 };
37    println!("x = {}", p.get_x());
38    println!("y = {}", p.get_y());
39
40    let p1 = Point2 { x: 5, y: 1.1 };
41    let p2 = Point2 { x: "hello", y: 'c' };
42    let p3 = p1.creat_point(p2);
43    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
44}

6、总结：使用泛型并不会造成程序性能上的损失。Rust通过在编译时进行泛型代码的单态化来保证效率。单态化时通过填充编译时使用的具体类型，将通用代码转换为特定代码的过程。

本节全部源代码：
https://github.com/anonymousGiga/learn_rust/blob/master/learn_T/src/main.rs