Jenner's Blog

不变秃，也要变强！

0%

Rust之trait

发表于 分类于 ， Valine：

行为上对类型的约束

trait是Rust对Ad-hoc（点对点/特别的/临时的）多态的支持。

接口抽象

  • 接口中可以定义方法，并支持默认实现；
1
2
3
4
5
6
7
8
9
trait NoiseMaker {
    fn make_noise(&self);
    
    fn make_alot_of_noise(&self){
        self.make_noise();
        self.make_noise();
        self.make_noise();
    }
}
  • 接口中不能实现另一个接口，但是接口之间可以继承；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
trait NoiseMaker {
    fn make_noise(&self);
}

trait LoudNoiseMaker: NoiseMaker {
    fn make_alot_of_noise(&self) {
        self.make_noise();
        self.make_noise();
        self.make_noise();
    }
}

impl NoiseMaker for SeaCreature {
    fn make_noise(&self) {
        println!("{}", &self.get_sound());
    }
}

impl LoudNoiseMaker for SeaCreature {}
  • 同一个接口可以同时被多个类型实现，但不能被同一个类型实现多次；

为不同的类型实现trait，属于一种函数重载，也是Ad-hoc多态。

关联类型

1
2
3
4
pub trait Add<RHS = Self> {
	type Output;
	fn add(self, rhs: RHS) -> Self::Output;
}

Self是每个trait都带有的隐式类型参数，代表实现当前trait的具体类型。实现时，未指明泛型，默认为Self类型。

Output为关联类型。

为u32类型实现Add trait

1
2
3
4
impl Add for u32 {
    type Output = u32;
    fn add (self, other: u32) -> u32 { self + other }
}

关联类型的作用

关联类型在trait定义中指定占位符类型。trait 的实现者会针对特定的实现在这个类型的位置指定相应的具体类型。如此可以定义一个使用多种类型的 trait。

1
2
3
4
5
6
7
8
pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}
// 为什么不像下面这样写，使用泛型？
// pub trait Iterator<T> {
//    fn next(&mut self) -> Option<T>;
// }

使用泛型的方式，则如例子中在实现trait的时候必须带上具体的类型，调用时也必须带上具体的类型。

孤儿规则

如果要实现某个trait，那么该trait和实现该trait的那个类型至少有一个要在当前crate中定义。

绕开这个限制的方法是使用 newtype 模式（newtype pattern）。

1
2
3
4
5
6
7
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({})", self.0.join(","))
    }
}

在上述例子中，我们在 Vec 上实现 Display，而孤儿规则阻止我们直接这么做，因为 Display trait 和 Vec 都定义于我们的 crate 之外。我们可以创建一个包含 Vec 实例的 Wrapper 结构体，然后再实现。

trait继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
trait Page{
    fn set_page(&self, p: i32){
        println!("Page Default: 1");
    }
}
trait PerPage{
    fn set_perpage(&self, num: i32){
        println!("Per Page Default: 10");
    }
}
trait Paginate: Page + PerPage{
    fn set_skip_page(&self, num: i32){
        println!("Skip Page : {:?}", num);
    }
}
impl <T: Page + PerPage>Paginate for T{}
struct MyPaginate{ page: i32 }
impl Page for MyPaginate{}
impl PerPage for MyPaginate{}
fn main() {
    let my_paginate = MyPaginate{page: 1};
	my_paginate.set_page(2);
	my_paginate.set_perpage(100);
	my_paginate.set_skip_page(12);
}

impl <T: Page + PerPage>Paginate for T{} 为拥有Page和PerPage行为的类型实现Paginate。

使用继承，可以不影响之前的代码，加入上面这一行就可以添加新的trait。

泛型约束

1
2
3
4
5
6
7
8
use std::ops::Add;
fn sum<T: Add<T, Output=T>>(a: T, b: T) -> T{
// where
  // T: Add<T, Output=T>
    a + b
}
assert_eq!(sum(1u32, 2u32), 3);
assert_eq!(sum(1u64, 2u64), 3);

约束sum函数，只有实现了Add这个trait的类型才可以当做参数。

where关键字，可以把泛型中的trait限定移到语句最后。

抽象类型

trait对象

trait的类型大小在编译期间无法确定，所以trait对象必须使用指针。可以利用引用操作符&或Box<T>来制造一个trait对象。trait对象的结构体包含一个可变data指针和一个可变虚表指针。

作参数时，trait限定是静态分发的，trait对象是动态分发的。

impl Trait

静态分发的抽象类型impl Trait。目前只可以在输入的参数和返回值两个位置使用。

1
2
3
4
5
6
7
8
9
10
11
fn fly_static(s: impl Fly + Debug) -> bool {
	s.fly()
}
fn can_fly(s: impl Fly+Debug) -> impl Fly {
    if s.fly(){
        //...
    } else {
        //...
    }
    s
}

impl Trait只能用于单个参数指定抽象类型。

dyn Trait是与impl Trait相对应的动态分发。

标签trait

5个重要的标签：Sized（编译器可确定大小），Unsize（动态大小），Copy（可以按位复制），Send（跨线程安全通信），Sync（线程间安全共享引用）。

trait对象的生命周期

  • trait对象的生命周期默认是’static；
  • 如果实现trait的类型包含&’a X 或者 &’a mut X，则默认生命周期是’a；
  • 如果实现trait的类型只有T: ‘a，则默认生命周期是’a；
  • 如果实现trait的类型包含多个类似T:’a 的从句，则生命周期需要明确指定。

动态分发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
struct Duck;
struct Pig;
trait Fly {
    fn fly(&self) -> bool;
}
impl Fly for Duck {
    fn fly(&self) -> bool {
        true
    }
}
impl Fly for Pig {
    fn fly(&self) -> bool {
        false
    }
}
fn fly_static<F: Fly>(s: F) -> bool {
    s.fly()
}
fn fly_dyn(s: &dyn Fly) -> bool {
    s.fly()
}
//fn fly_dyn(s: &impl Fly) -> bool {
//    s.fly()
//}

fn main() {
    let pig = Pig;
    assert_eq!(fly_static::<Pig>(pig), false);
    let duck = Duck;
    assert_eq!(fly_static::<Duck>(duck), true);
  // 需要推断具体类型
    assert_eq!(fly_dyn(&Pig), false);
    assert_eq!(fly_dyn(&Duck), true);
}

fly_static是静态分发，fly_dyn是动态分发。Trait对象拥有实例对象方法的指针（定义在该Trait中的），类似于C++的虚函数表。

内存细节：动态分发会稍慢，因为要推断类型，去查找真正的函数调用。

完全限定语法

同名方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
trait Trait {
    fn foo(&mut self, x: i32);
}

struct Foo;

impl Foo {
    fn foo(&self) {
        println!("Foo::foo");
    }
}

impl Trait for Foo {
    fn foo(&mut self, x: i32) {
        //self.foo(); 　　　//１、出错点１ (&*self).foo();　按照此方式或者Self::foo(self)调用ok
        println!("Trait::foo {}", x);
    }
}

fn main() {
    let mut a: Foo = Foo {};
    a.foo();
    //a.foo(3); //２、出错点２，此方式调用出错 Trait::foo(&mut a, 3);
}

Rust在进行方法解析的时候试用的规则比较简单，编译器查看方法“ receiver”（. 之前的东西，在本例中为self，其类型为＆mut Foo），并检查它是否具有称为foo的方法。如果没有foo方法，则尝试借用或取消引用接收方后，再次检查是否有此方法。编译器会一直重复此过程，直到找到匹配的方法为止。 在此例中，编译器就会匹配到fn foo(&mut self, x: i32)方法，但是没有足够的参数，所以按照出错点１的写法会出错，正确的方式是显示地调用。
默认会调用Foo类型的foo方法，那么如果要调用trait中的方法怎么办呢？用trait名显示调用即可Trait::foo(&mut a, 3);。

关联函数的完全限定语法

当不能判断由哪个类型实现的方法来调用，需要使用完全限定语法：

<Type as Trait>::function(receiver_if_method, next_arg, ...);

点击下方打赏按钮，获得支付宝二维码