喜欢的话别忘了点赞、收藏加关注哦，对接下来的教程有兴趣的可以关注专栏。谢谢喵！(=･ω･=)
题外话：泛型的概念非常非常非常重要！！！整个第10章全都是Rust的重难点！！！
10.2.1. 什么是泛型
泛型的主要功能是提高代码的复用能力，适用于处理重复代码的问题，也可以说是实现数据与算法的分离。
泛型是具体类型或其它属性的抽象代替。 它的意思是你写代码时写的泛型代码并不是最终的代码，而是一种模版，里面有一些“占位符”。
编译器在编译时会把“占位符”替换为具体的类型。 还是看个例子:
fn largest<T>(list:&[T]) -> T {
//......
}
这个函数的定义就使用了泛型类型参数，这个T就是所谓的“占位符”，写代码时这个T可以是任意的数据类型，但是在编译时编译器会根据具体的使用把T替换为具体的类型，这个过程叫单态化。
这个T叫做泛型的类型参数。其实可以使用任意合法的标识符来作为它的类型参数的名，但是按惯例通常是使用大写的T(代表Type)。其实在选择泛型类型参数名的时候，它的名称是很短的，通常一个字母就够了。如果你实在要写长一点，使用驼峰命名规范即可。
10.2.2. 函数定义中的泛型
当使用泛型来定义一个函数的时候，需要将泛型的类型参数放在函数的签名里。而泛型的类型参数通常是用于指定参数和返回的类型。
以上一篇文章的代码为例，使用泛型稍作修改：
fn largest<T>(list: &[T]) -> T{
let mut largest = list[0];
for &item in list{
if item > largest{
largest = item;
}
}
largest
}
整个函数的定义可以这么理解：函数largest拥有泛型的类型参数T，它接收切片作为参数，切片内的元素为T，而这个元素返回值的类型也是T。
尝试编译一下，输出：
error[E0369]: binary operation `>` cannot be applied to type `T`
--> src/main.rs:4:17
|
4 | if item > largest{
| ---- ^ ------- T
| |
| T
|
help: consider restricting type parameter `T`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T{
| ++++++++++++++++++++++
这里先不讲原因和修改的方法，只需要知道使用泛型参数大概是这么个写法就对了。后面的文章会讲如何指定特定的trait。
10.2.3. struct定义中的泛型
结构体里定义的泛型类型参数主要是用在它的字段里，看个例子：
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 };
}
在结构体的名字后面呢加上<>，在里面写泛型参数的名称，而这个泛型类型就可以应用于这个结构体下的每个字段。
在main函数里实现了这个结构体的实例化，integer里的两个字段是两个i32，float里的两个字段是两个f64，因为结构体在声明时x和y的类型都是T，所以实例化的x和y的类型也得是一个类型，两者的类型得保持一致。
那如果我想要x和y是两种不同的类型呢？很简单，声明两个泛型类型就可以：
struct Point<T, U> {
x: T,
y: U,
}
fn main() {
let integer = Point { x: 5, y: 1.0 };
let float = Point { x: 1.0, y: 40 };
}
这个时候实例化的x和y就可以是不同的类型，当然也可以是一样的类型。
需要注意的是，虽然可以使用多个泛型类型参数，但是，太多的泛型会使得可读性下降，通常这意味着代码需要重组为更多的小单元。
10.2.4. enum定义中的泛型
和结构体差不多，枚举中使用泛型类型参数主要是用在变体中华，可以让枚举的变体持有泛型数据类型，比如说最常见的Option<T>和Result<T, E>。
看个例子：
enum Option<T> {
Some(T),
None,
}
enum Result<T, E> {
Ok(T),
Err(E),
}
Option枚举中Some(T)也就是Some这个变体持有T类型的值，而None这个变体表示不持有任何值。而正是因为Option枚举使用了泛型，所以无论这个可能存在的值是什么类型的，都可以使用Option<T>来表示- 同样的，枚举的类型参数也可以使用多个泛型类型参数，比如说
Result这个枚举就使用了T和E,在变体Ok里存储的是T,Err存储的是E
10.2.5. 在方法定义中的泛型
方法可以附在枚举或是结构体上，既然枚举和结构体都可以使用泛型参数，那方法自然也可以，如下例：
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
方法x相当于一个getter，而针对Poinnt<T>这个结构来实现方法的时候需要在impl关键字的后面加上<T>。这样写就表示它是针对泛型T而不是针对某个具体的类型来实现的。
当然，如果是根据具体的类型来实现方法就不需要了:
impl Point<i32> {
fn x1(&self) -> &i32 {
&self.x
}
}
而x1这个方法就只有在Point<i32>这个具体的类型上才有，而其他Point<T>的类型就没有这个方法，类比C++的特化和偏特化。
还有一点需要注意，结构体里的泛型类型参数可以和方法的泛型类型参数不同。看个例子：
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);
}
针对Point<T, U>实现了方法mixup，mixup有两个泛型类型参数，一个叫V，一个叫W,方法的两个类型参数和Point的两个类型参数是不一样的，当然具类型也有可能是一样的。mixup的第二个参数是other，它的类型也是Point，但这个Point不一定和self所指向的Point的数据类型是一样的，所以需要另起2个新的泛型类型参数。再看看返回类型，是Point<T, W>，T来自Point<T, U>，W来自Point<V, W>。
看下main函数，首先声明了p1,它的两个字段都是i32；然后又声明了p2，它的两个字段分别是&str（字符串切片）和char（用''代表是单个字符）。接着使用了mixup这个函数，p1对应的是Point<T, U>，p2对应的是Point<V, W>，又根据各自的字段的类型可以推断出T是i32，U是i32，V是String，W是char。mixup返回类型是Point<T, W>，具体到这个例子中就是Point<i32, char>。
输出：
p3.x = 5, p3.y = c
10.2.6. 泛型代码的性能
使用泛型的代码和使用具体类型的代码的运行速度是一样的。Rust在编译时会执行单态化，将泛型类型替换为具体的类型，这样在执行的时候就省去了类型替换的过程。
举个例子:
fn main() {
let integer = Some(5);
let float = Some(5.0)
}
这里integer是Option<i32>，float是Option<f64>，在编译的时候编译器会把Option<T>展开为Option_i32和Option_f64：
enum Option_i32 {
Some(i32),
None,
}
enum Option_f64 {
Some(f64),
None,
}
也就是把Option<T>这个泛型定义替换为了两个具体类型的定义。
单态后的main函数也变成了这样：
enum Option_i32 {
Some(i32),
None,
}
enum Option_f64 {
Some(f64),
None,
}
fn main(){
let integer = Option_i32::Some(5);
let float = Option_f64::Some(5.0);
}
