Rust范型(1) - 范型基础

简介

C/C++、Rust都属于强类型语言，在定义变量或者是传参时，必须明确指定数据的数据类型。明确指定类型对于程序员，或者是编译器来讲，可以使得阅读代码更加清晰，但是很多时候，显示指定类型会带来大量重复的代码。比如实现类似链表这样的数据结构，链表中保存的数据可以是int，可以是uint64，还可以是String，也可以是其他类型，针对每一种类型，实际上代码结构上是完全相同的，仅仅是数据类型不同而已。此外，比如排序算法，打印函数等等，也是同样的道理。

为了简化代码，可以将“数据表征的能力”与数据类型解耦，将类型抽象为一种“参数”，而数据和算法针对于这种抽象的类型来实现，而不是具体的类型。在数据和算法实现完成后，再用具体的类型将抽象的参数实例化，这个将类型抽象化的机制，就叫做“范型”

观感

下面实现求解一个数组的最大值。
当数据类型是整形时：

fn find_max(array: &[i32]) -> i32 {
    let mut max = array[0];
    for &i in array.iter() {
        if i > max {
            max = i;
        }
    }
    max
}

当数据类型是字符时：

fn find_max(array : &[char]) -> char {
    let mut max = array[0];
    for &i in list.iter() {
        if i > max {
            max = i;
        }
    }
    max
}

这两个函数除了参数列表中的数据结构不一样外，其他全部一样，如果采用范型来实现，可以合并为如下：

fn find_max<T: std::cmp:: PartialOrd + Copy>(array: &[T]) -> T {
    let mut max = array[0];
    for &i in list.iter() {
        if i > max {
            max = i;
        }
    }
    max
}

在调用该函数时，T可以根据实际的参数类型进行适配:

fn main() {
    let v_int = vec![1, 2, 3, 4, 5, 6];
    println!("max_int: {}", find_max(&v_int));

    let v_char = vec!['A', 'B', 'C', 'D', 'E'];
    println!("max_char: {}", find_max(&v_char));
}

在上文中，范型实现的find_max函数在指定范型T时，添加了范型约束T: std::cmp:: PartialOrd + Copy，我们将在后文进行分析。

结构体与枚举类中的泛型

Rust中大量的枚举与结构体中使用到范型，典型如Option

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

因为Option包裹的内容并没有指定具体的类型，所以，任意类型均可以被Option包裹。

常见类型还有Result:

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

在结构体中使用范型的示例如下：

struct Point<T> {
    x: T,
    y: T
}

Point类型定义了一个坐标点，使用方法如下：

let p1 = Point {x: 1, y: 2};
let p2 = Point {x: 1.0, y: 2.0};

范型绑定具体的类型是自动完成的，也就是说，在创建Point结构体时，会自动根据传入的参数类型确定范型T的语义。

注意，尽管范型语义是自动绑定的，但是传入的参数类型必须符合结构体的定义。
比如这样的定义就是错误的：

let p = Point {x: 1, y: 2.0};

在x变量与1绑定时，范型T就被设定为i32了，所以在绑定变量y时，会出现类型不匹配情况。

为了要支持x与y类型不一样，可以将Point定义中使用不同的范型：

struct Point<T1, T2> {
    x: T1,
    y: T2
}

使用了范型的结构体与枚举在定义方法时，也应该实现范型的机制，否则包含泛型的结构将无法被有效的方法操作。

示例如下：

struct Point<T> {
    x: T,
    y: T,
}

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

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

值得注意的是，impl 关键字的后方必须有 <T>。

在为某一个包含范型的结构体实现方法时，也可以显式指定具体类型：

impl Point<usize> {
    fn x(&self) -> f64 {
        self.x
    }
}