在函数定义中使用泛型

使用泛型定义函数时，本来在函数签名中指定参数和返回值类型的地方，改用泛型来表示。

  1. fn largest<T>(list: &[T]) -> T {
  2.     let mut largest = list[0];
  4.     for &item in list {
  5.         if item > largest {
  6.             largest = item;
  7.         }
  8.     }
  10.     largest
  11. }
  13. fn main() {
  14.     let number_list = vec![34, 50, 25, 100, 65];
  16.     let result = largest(&number_list);
  17.     println!("The largest number is {}", result);
  19.     let char_list = vec!['y', 'm', 'a', 'q'];
  21.     let result = largest(&char_list);
  22.     println!("The largest char is {}", result);
  23. }

结构体定义中的泛型

  1. struct Point<T> {
  2.     x: T,
  3.     y: T,
  4. }
  6. fn main() {
  7.     let integer = Point { x: 5, y: 10 };
  8.     let float = Point { x: 1.0, y: 4.0 };
  9. }
  1. struct Point<T, U> {
  2.     x: T,
  3.     y: U,
  4. }
  6. fn main() {
  7.     let both_integer = Point { x: 5, y: 10 };
  8.     let both_float = Point { x: 1.0, y: 4.0 };
  9.     let integer_and_float = Point { x: 5, y: 4.0 };
  10. }

枚举定义中的泛型

  1. enum Option<T> {
  2.     Some(T),
  3.     None,
  4. }

方法定义中的泛型

  1. struct Point<T> {
  2.     x: T,
  3.     y: T,
  4. }
  6. impl<T> Point<T> {
  7.     fn x(&self) -> &T {
  8.         &self.x
  9.     }
  10. }
  12. fn main() {
  13.     let p = Point {x: 5, y: 10};
  15.     println!("p.x = {}", p.x());
  16. }

可以定义方法适用于某些有限制的泛型类型。

  1. impl Point<f32> {
  2.     fn distance_from_origin(&self) -> f32 {
  3.         (self.x.powi(2) + self.y.powi(2)).sqrt()
  4.     }
  5. }

这段代码意味着 Point 类型会有一个方法 distance_from_origin，而其他 T 不是 f32 类型的 Point 实例则没有定义此方法。

泛型代码的性能

Rust 通过编译时进行泛型代码的单态化来保证效率。单态化：一个通过填充编译时使用的具体类型，将通用代码转换为特定代码的过程。