Rust指南之泛型与特性详解

目录

• 前言
• 1、泛型
• 1.1、在函数中定义泛型
• 1.2、结构体中的泛型
• 1.3、枚举类中的泛型
• 1.4、方法中的泛型
• 2、特性
• 2.1、默认特性
• 2.2、特性做参数
• 2.3、特性做返回值

前言

在上篇Rust 文章中涉及到了泛型的知识，那么今天就来详细介绍一下Rust 中的泛型与特性。泛型是一个编程语言不可或缺的机制，例如在C++ 语言中用模板来实现泛型。泛型机制是编程语言用于表达类型抽象的机制，一般用于功能确定、数据类型待定的类，如链表、映射表等。

1、泛型

泛型是具体类型或其他属性的抽象代替：

• 所编写的泛型代码并非最终程序运行的代码，而是一种模板，含有一些"占位符"
• 编译器在编译的时候将"占位符" 替换为具体的数据类型

优点：

提高代码复用能力

• 减少代码重复

1.1、在函数中定义泛型

例如，定义一个对整型数字选择排序的函数：

fn max(array: &[i32]) -> i32 {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}

fn main() {
    let a = [3, 4, 6, 8, 1];
    println!("max = {}", max(&a));
}
//运行结果：max = 8

这是一个简单的取最大值程序，可以用于处理 i32 数字类型的数据，但无法用于 f64 类型的数据。

通过使用泛型我们可以使这个函数可以利用到各个类型中去：

fn max<T>(array: &[T]) -> T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}

实际上，并不是所有的数据类型都可以比大小。当T被自定义的结构体或者枚举等类型替代时，这段代码肯定就会报错。所以这段代码并不是用来运行的，而是用来描述一下函数泛型的语法格式。

1.2、结构体中的泛型

结构体泛型举例：点坐标结构体，T 表示描述点坐标的数据类型：

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

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

使用时并没有声明类型，这里使用的是自动类型机制，但不允许出现类型不匹配的情况如下：

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

x 与 1 绑定时就已经将 T 设定为 i32，所以不允许再出现 f64 的类型。如果我们想让 x 与 y 用不同的数据类型表示，可以使用两个泛型标识符：

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

1.3、枚举类中的泛型

在枚举类中表示泛型的方法诸如 Option 和 Result：

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

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

枚举类的具体使用可参考本专栏的文章，有较为详细的讲解。

1.4、方法中的泛型

结构体与枚举类都可以定义方法，那么方法也应该实现泛型的机制，否则泛型的类将无法被有效的方法操作。

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

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

fn main() {
    let p = Point { x: 2, y: 4 };
    println!("p.x = {}", p.x());
}
//运行结果：p.x = 1

注意，impl 关键字的后方必须有 <T>，因为它后面的 T 是以之为榜样的。

我们也可以为其中的一种泛型添加方法：

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

impl 块本身的泛型并没有阻碍其内部方法具有泛型的能力

例如：

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

方法 mixup 将一个 Point<T, U> 点的 x 与 Point<V, W> 点的 y 融合成一个类型为 Point<T, W> 的新点。

2、特性

特性（trait）概念接近于 Java 中的接口（Interface），但两者不完全相同。特性与接口相同的地方在于它们都是一种行为规范，可以用于标识哪些类有哪些方法。

特性在 Rust 中用 trait 表示：

trait Descript {
    fn describe(&self) -> String;
}

Descript 规定了实现者必需有 describe(&self) -> String 方法。

例如：

struct Person {
    name: String,
    age: u16
}

impl Descript for Person {
    fn describe(&self) -> String {
        format!("{} {}", self.name, self.age)
    }
}

格式：

• impl <特性名> for <所实现的类型名>

Rust 同一个类可以实现多个特性，每个 impl 块只能实现一个

2.1、默认特性

这是特性与接口的不同点：

• 接口只能规范方法而不能定义方法
• 特性可以定义方法作为默认方法
  • 因为是"默认"，所以对象对于是否重新定义方法是自由的

举个例子：

trait Descript {
    fn describe(&self) -> String {
        String::from("[Object]")
    }
}

struct Person {
    name: String,
    age: u8
}

impl Descript for Person {
    fn describe(&self) -> String {
        format!("{} {}", self.name, self.age)
    }
}

fn main() {
    let zhangsan = Person {
        name: String::from("kuangtu"),
        age: 28
    };
    println!("{}", zhangsan.describe());
}
//运行结果：kuangtu 28

如果将 impl Descript for Person 块中的内容去掉，那么运行结果就是 [Object]

2.2、特性做参数

很多情况下我们需要传递一个函数做参数，例如回调函数、设置按钮事件等。在 Java 中函数必须以接口实现的类实例来传递，在 Rust 中可以通过传递特性参数来实现：

fn output(object: impl Descript) {
    println!("{}", object.describe());
}

任何实现了 Descript 特性的对象都可以作为这个函数的参数，这个函数没必要知道传入对象有没有其他属性或方法，只需要了解它一定有 Descript 特性规范的方法就可以了。当然，此函数内也无法使用其他的属性与方法。

特性参数还可以用这种等效语法实现：

fn output<T: Descriptive>(object: T) {
    println!("{}", object.describe());
}

这是一种风格类似泛型的语法糖，这种语法糖在有多个参数类型均是特性的情况下十分实用：

fn output_two<T: Descriptive>(arg1: T, arg2: T) {
    println!("{}", arg1.describe());
    println!("{}", arg2.describe());
}

特性作类型表示时如果涉及多个特性，可以用 + 符号表示，例如：

fn notify(item: impl Summary + Display)
fn notify<T: Summary + Display>(item: T)

注意：仅用于表示类型的时候，并不可以在 impl 块中使用。

复杂的实现关系可以使用 where 关键字简化，例如：

fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U)

可以简化为：

fn some_function<T, U>(t: T, u: U) -> i32
    where T: Display + Clone,
          U: Clone + Debug

泛型通过与特性的结合可以实现上面任意类型值比较的案例：

trait Comparable {
    fn compare(&self, object: &Self) -> i8;
}

fn max<T: Comparable>(array: &[T]) -> &T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i].compare(&array[max_index]) > 0 {
            max_index = i;
        }
        i += 1;
    }
    &array[max_index]
}

impl Comparable for f64 {
    fn compare(&self, object: &f64) -> i8 {
        if &self > &object { 1 }
        else if &self == &object { 0 }
        else { -1 }
    }
}

fn main() {
    let arr = [1.0, 3.0, 7.0, 4.0, 2.0];
    println!("maximum of arr is {}", max(&arr));
}
//运行结果：maximum of arr is 7

Tip: 由于需要声明 compare 函数的第二参数必须与实现该特性的类型相同，所以 Self （注意大小写）关键字就代表了当前类型（不是实例）本身。

2.3、特性做返回值

格式如下：

fn person() -> impl Descript {
    Person {
        name: String::from("Cali"),
        age: 24
    }
}

注意：特性做返回值只接受实现了该特性的对象做返回值且在同一个函数中所有可能的返回值类型必须完全一样。

比如结构体 A 与结构体 B 都实现了特性 Trait，下面这个函数就是错误的：

fn some_function(bool bl) -> impl Descriptive {
    if bl {
        return A {};
    } else {
        return B {};
    }
}

到此这篇关于Rust指南泛型与特性的文章就介绍到这了,更多相关Rust泛型与特性内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！