• 10.1 trait关键字
    • trait与具体类型
    • trait与泛型
      • 泛型的trait约束
      • 多trait约束
      • where关键字
  • trait与内置类型
  • trait的默认方法
  • trait的继承
  • derive属性

    10.1 trait关键字

    trait与具体类型

    使用trait定义一个特征：

    1. trait HasArea {
    2.     fn area(&self) -> f64;
    3. }

    trait里面的函数可以没有函数体，实现代码交给具体实现它的类型去补充：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl HasArea for Circle {
    8.     fn area(&self) -> f64 {
    9.         std::f64::consts::PI * (self.radius * self.radius)
    10.     }
    11. }
    13. fn main() {
    14.     let c = Circle {
    15.         x: 0.0f64,
    16.         y: 0.0f64,
    17.         radius: 1.0f64,
    18.     };
    19.     println!("circle c has an area of {}", c.area());
    20. }

    注: &self表示的是area这个函数会将调用者的借代引用作为参数

    这个程序会输出：

    1. circle c has an area of 3.141592653589793

    trait与泛型

    我们了解了Rust中trait的定义和使用，接下来我们介绍一下它的使用场景，从中我们可以窥探出接口这特性带来的惊喜

    我们知道泛型可以指任意类型，但有时这不是我们想要的，需要给它一些约束。

    泛型的trait约束

    1. use std::fmt::Debug;
    2. fn foo<T: Debug>(s: T) {
    3.     println!("{:?}", s);
    4. }

    Debug是Rust内置的一个trait，为”{:?}”实现打印内容，函数foo接受一个泛型作为参数，并且约定其需要实现Debug

    多trait约束

    可以使用多个trait对泛型进行约束：

    1. use std::fmt::Debug;
    2. fn foo<T: Debug + Clone>(s: T) {
    3.     s.clone();
    4.     println!("{:?}", s);
    5. }

    <T: Debug + Clone>中Debug和Clone使用+连接，标示泛型T需要同时实现这两个trait。

    where关键字

    约束的trait增加后，代码看起来就变得诡异了，这时候需要使用where从句：

    1. use std::fmt::Debug;
    2. fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) {
    3.     x.clone();
    4.     y.clone();
    5.     println!("{:?}", y);
    6. }
    8. // where 从句
    9. fn foo<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug {
    10.     x.clone();
    11.     y.clone();
    12.     println!("{:?}", y);
    13. }
    15. // 或者
    16. fn foo<T, K>(x: T, y: K)
    17.     where T: Clone,
    18.           K: Clone + Debug {
    19.     x.clone();
    20.     y.clone();
    21.     println!("{:?}", y);
    22. }

    trait与内置类型

    内置类型如：i32, i64等也可以添加trait实现，为其定制一些功能：

    1. trait HasArea {
    2.     fn area(&self) -> f64;
    3. }
    5. impl HasArea for i32 {
    6.     fn area(&self) -> f64 {
    7.         *self as f64
    8.     }
    9. }
    11. 5.area();

    这样的做法是有限制的。Rust 有一个“孤儿规则”：当你为某类型实现某 trait 的时候，必须要求类型或者 trait 至少有一个是在当前 crate 中定义的。你不能为第三方的类型实现第三方的 trait 。

    在调用 trait 中定义的方法的时候，一定要记得让这个 trait 可被访问。

    1. let mut f = std::fs::File::open("foo.txt").ok().expect("Couldn’t open foo.txt");
    2. let buf = b"whatever"; //  buf: &[u8; 8]
    3. let result = f.write(buf);
    4. # result.unwrap();

    这里是错误：

    1. error: type `std::fs::File` does not implement any method in scope named `write`
    2. let result = f.write(buf);
    3.                ^~~~~~~~~~

    我们需要先use这个Write trait：

    1. use std::io::Write;
    3. let mut f = std::fs::File::open("foo.txt").expect("Couldn’t open foo.txt");
    4. let buf = b"whatever";
    5. let result = f.write(buf);
    6. # result.unwrap(); // ignore the error

    这样就能无错误地编译了。

    trait的默认方法

    1. trait Foo {
    2.     fn is_valid(&self) -> bool;
    4.     fn is_invalid(&self) -> bool { !self.is_valid() }
    5. }

    is_invalid是默认方法，Foo的实现者并不要求实现它，如果选择实现它，会覆盖掉它的默认行为。

    trait的继承

    1. trait Foo {
    2.     fn foo(&self);
    3. }
    5. trait FooBar : Foo {
    6.     fn foobar(&self);
    7. }

    这样FooBar的实现者也要同时实现Foo：

    1. struct Baz;
    3. impl Foo for Baz {
    4.     fn foo(&self) { println!("foo"); }
    5. }
    7. impl FooBar for Baz {
    8.     fn foobar(&self) { println!("foobar"); }
    9. }

    derive属性

    Rust提供了一个属性derive来自动实现一些trait，这样可以避免重复繁琐地实现他们，能被derive使用的trait包括：Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd

    1. #[derive(Debug)]
    2. struct Foo;
    4. fn main() {
    5.     println!("{:?}", Foo);
    6. }