Rust 高级 trait

636 字

3 分钟

Rust 高级 trait

2023-12-14

rust

泛型#

例如定义两个类型，一个是 Millimeters，一个是 Meters，并且定义一个 add 方法，用于将两个类型相加。

1
struct Millimeters(u32);
2
struct Meters(u32);

看看 Add trait 的定义：

1
trait Add<Rhs=Self> {
2
    type Output;
3

4
    fn add(self, rhs: Rhs) -> Self::Output;
5
}

其中 Rhs 是一个泛型类型，Self 是实现 Add trait 的类型。type Output 是 add 方法的返回类型。

为了实现两个不同类型的相加，需要将 Rhs 设置为 Meters，Self 设置为 Millimeters，Output 设置为 Millimeters。

1
use std::ops::Add;
2

3
impl Add<Meters> for Millimeters {
4
    type Output = Millimeters;
5

6
    fn add(self, other: Meters) -> Millimeters {
7
        Millimeters(self.0 + (other.0 * 1000))
8
    }
9
}
10

11
fn main() {
12
    let a = Millimeters(10);
13
    let b = Meters(1);
14
    dbg!(a + b);
15
}

输出结果:

1
[src/main.rs:19] a + b = Millimeters(
2
    1010,
3
)

完全限定语法#

完全限定语法（fully qualified syntax）可以用来消除歧义，例如：

1
trait Pilot {
2
    fn fly(&self);
3
}
4

5
trait Wizard {
6
    fn fly(&self);
7
}
8

9
struct Human;
10

11
impl Pilot for Human {
12
    fn fly(&self) {
13
        println!("This is your captain speaking.");
14
    }
15
}
16

17
impl Wizard for Human {
18
    fn fly(&self) {
19
        println!("Up!");
20
    }
21
}
22

23
impl Human {
24
    fn fly(&self) {
25
        println!("*waving arms furiously*");
26
    }
27
}
28

29
fn main() {
30
    let person = Human;
31
    Pilot::fly(&person);
32
    Wizard::fly(&person);
33
    person.fly();
34
}

输出：

1
This is your captain speaking.
2
Up!
3
*waving arms furiously*

扩展 trait#

实现一个 trait 时，可以使用 trait TraitName: AnotherTraitName 语法来扩展 trait。

1
use std::fmt;
2

3
trait OutlinePrint: fmt::Display {
4
    fn outline_print(&self) {
5
        let output = self.to_string();
6
        let len = output.len();
7
        println!("{}", "*".repeat(len + 4));
8
        println!("*{}*", " ".repeat(len + 2));
9
        println!("* {} *", output);
10
        println!("*{}*", " ".repeat(len + 2));
11
        println!("{}", "*".repeat(len + 4));
12
    }
13
}

为 Point 实现：

1
struct Point {
2
    x: i32,
3
    y: i32,
4
}
5

6
impl OutlinePrint for Point {}
7

8
use std::fmt;
9

10
impl fmt::Display for Point {
11
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
12
        write!(f, "({}, {})", self.x, self.y)
13
    }
14
}
15

16
fn main() {
17
    let p = Point { x: 1, y: 3 };
18
    p.outline_print();
19
}

输出：

1
**********
2
*        *
3
* (1, 3) *
4
*        *
5
**********

孤儿规则#

孤儿规则（orphan rule）是 Rust 中的一个限制，它规定了只有当 trait 或类型对于当前 crate 是本地的时候，才可以在该类型上实现该 trait。这样可以避免不同 crate 之间出现相同的 trait 实现的冲突。要绕过这个限制，可以使用 newtype 模式，即在一个元组结构体中封装其类型，然后在这个新类型上实现 trait。

使用这个模式没有运行时性能惩罚，这个封装类型在编译时就被省略了。

例如，Vec<T> 实现 Display trait 是已被定义，但是我们可以定义一个新类型 Wrapper，并为它实现。

1
use std::fmt;
2

3
struct Wrapper(Vec<String>);
4

5
impl fmt::Display for Wrapper {
6
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7
        write!(f, "[{}]", self.0.join(", "))
8
    }
9
}
10

11
fn main() {
12
    let w = Wrapper(vec![String::from("hello"), String::from("world")]);
13
    println!("w = {}", w);
14
}

或者你可以使用 type alias：

1
use std::fmt;
2

3
type Wrapper = Vec<String>;
4

5
impl fmt::Display for Wrapper {
6
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7
        write!(f, "[{}]", self.join(", "))
8
    }
9
}