泛型

当需要在函数体中使用一个参数时
必须在函数签名中声明这个参数
以便编译器能知道函数体中这个名称的意义
同理
当在函数签名中使用一个类型参数时
必须在使用它之前就声明它

为了定义泛型版本的 largest 函数
类型参数声明位于 函数名称 与参数列表中间的尖括号 <> 中

 fn largest<T>(list: &[T]) -> T {}

这可以理解为:

• 函数 largest 有泛型类型 T
• 它有一个参数 list 它的类型是一个 T 值的 slice
• largest 函数将会返回一个与 T 相同类型的值

看一段有问题的代码

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 的所有可能的类型
因为在函数体需要比较T类型的值
这个比较局限在它知道如何排序的类型

为了开启比较功能，标准库中 定义的 std::cmp::PartialOrd trait
可以实现类型的比较功能

正确的代码:

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { 
         let mut largest = list[0];
         for &item in list.iter() {
                if item > largest { 
                       largest = item;
               } 
          }
          largest
 }
// 此处省略main函数

在 largest 函数体中我们想要使用大于运算符( > )比较两个 T 类型的值。
这个运算符被 定义为标准库中 trait std::cmp::PartialOrd 的一个默认方法。
所以需要在 T 的 trait bound 中指定 PartialOrd
这样 largest 函数可以用于任何可以比较大小的类型的 slice。
因为PartialOrd 位于 prelude 中所以并不需要手动将其引入作用域
同时
i32 和 char 这样的类型是已知大小的并可以储 存在栈上，所以他们实现了 Copy trait
当我们将 largest 函数改成使用泛型后，现在list 参数的类型就有可能是没有实现 Copy trait 的导致可能不能将 list[0] 的 值移动到 largest 变量中

结构体中定义的泛型

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

struct Point<T> {
    x: T,
    y: T, 
}
     impl<T> Point<T> {
          fn x(&self) -> &T {
              &self.x
          }
      }

fn main() {
     let p = Point { x: 5, y: 10 }; println!("p.x = {}", p.x());
}

枚举中定义的泛型

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