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

// 在结构体中使用泛型
#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

#[derive(Debug)]
struct Point2<T, U> {
    x: T,
    y: U,
}

fn main() {
    let integer = Point { x: 1, y: 2 };
    println!("{:#?}", integer);

    let float = Point { x: 1.1, y: 2.2 };
    println!("{:?}", float);

    let a = Point2 { x: 1.1, y: 'a' };
    println!("a = {:?}", a);
}

4、枚举中的泛型。

// 在枚举中使用泛型
enum Option<T> {
    Some(T),
    None,
}

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

5、方法中的泛型。

// 在方法中使用泛型
struct Point<T> {
    x: T,
    y: T,
}

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

    fn get_y(&self) -> &T {
        &self.y
    }
}

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

impl<T, U> Point2<T, U> {
    fn creat_point<V, W>(self, other: Point2<V, W>) -> Point2<T, W> {
        Point2 {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    println!("x = {}", p.get_x());
    println!("y = {}", p.get_y());

    let p = Point { x: 1.1, y: 2.2 };
    println!("x = {}", p.get_x());
    println!("y = {}", p.get_y());

    let p1 = Point2 { x: 5, y: 1.1 };
    let p2 = Point2 { x: "hello", y: 'c' };
    let p3 = p1.creat_point(p2);
    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

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

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