深入特征
此笔记记录于Rust Course,大多数为其中的摘要,少数为笔者自己的理解
关联类型
关联类型是在特征定义的语句块中,申明一个自定义类型,这样就可以在特征的方法签名中使用该类型:
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
以上是标准库中的迭代器特征 Iterator
,它有一个 Item
关联类型,用于替代遍历的值的类型。
同时,next
方法也返回了一个 Item
类型,不过使用 Option
枚举进行了包裹,假如迭代器中的值是 i32
类型,那么调用 next
方法就将获取一个 Option<i32>
的值。
Self
用来指代当前调用者的具体类型,那么 Self::Item
就用来指代该类型实现中定义的 Item
类型:
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
// --snip--
}
}
fn main() {
let c = Counter{..}
c.next()
}
为何不用泛型,例如如下代码:
pub trait Iterator<Item> {
fn next(&mut self) -> Option<Item>;
}
为了代码的可读性,当你使用了泛型后,你需要在所有地方都写 Iterator<Item>
,而使用了关联类型,你只需要写 Iterator
,当类型定义复杂时,这种写法可以极大的增加可读性。
默认泛型类型参数
当使用泛型类型参数时,可以为其指定一个默认的具体类型,例如标准库中的 std::ops::Add
特征
trait Add<RHS=Self> {
type Output;
fn add(self, rhs: RHS) -> Self::Output;
}
它有一个泛型参数 RHS
,但是与我们以往的用法不同,这里它给 RHS
一个默认值,也就是当用户不指定 RHS
时,默认使用两个同样类型的值进行相加,然后返回一个关联类型 Output
。
use std::ops::Add;
#[derive(Debug, PartialEq)]
struct Point {
x: i32,
y: i32,
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
fn main() {
assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
Point { x: 3, y: 3 });
}
这里为 Point
结构体提供 +
的能力,这就是运算符重载,不过 Rust 并不支持创建自定义运算符,你也无法为所有运算符进行重载,目前来说,只有定义在 std::ops
中的运算符才能进行重载。
跟 +
对应的特征是 std::ops::Add
,我们在之前也看过它的定义 trait Add<RHS=Self>
,但是上面的例子中并没有为 Point
实现 Add<RHS>
特征,而是实现了 Add
特征(没有默认泛型类型参数),这意味着我们使用了 RHS
的默认类型,也就是 Self
。换句话说,我们这里定义的是两个相同的 Point
类型相加,因此无需指定 RHS
。
与上面的例子相反,下面的例子,我们来创建两个不同类型的相加:
use std::ops::Add;
struct Millimeters(u32);
struct Meters(u32);
impl Add<Meters> for Millimeters {
type Output = Millimeters;
fn add(self, other: Meters) -> Millimeters {
Millimeters(self.0 + (other.0 * 1000))
}
}
调用同名的方法
不同特征拥有同名的方法是很正常的事情,你没有任何办法阻止这一点;甚至除了特征上的同名方法外,在你的类型上,也有同名方法:
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
这里,不仅仅两个特征 Pilot
和 Wizard
有 fly
方法,就连实现那两个特征的 Human
单元结构体,也拥有一个同名方法 fly
调用顺序是:优先调用类型上的方法
为了能够调用两个特征的方法,需要使用显式调用的语法:
fn main() {
let person = Human;
Pilot::fly(&person); // 调用 Pilot 特征上的方法
Wizard::fly(&person); // 调用 Wizard 特征上的方法
person.fly(); // 调用 Human 类型自身的方法
}
因为 fly
方法的参数是 self
,当显式调用时,编译器就可以根据调用的类型( self
的类型)决定具体调用哪个方法。
这个时候问题又来了,如果方法没有 self
参数呢?此时就需要使用完全限定语法:
完全限定语法是调用函数最为明确的方式
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
}
在尖括号中,通过 as
关键字,我们向 Rust 编译器提供了类型注解,也就是 Animal
就是 Dog
,而不是其他动物,因此最终会调用 impl Animal for Dog
中的方法,获取到其它动物对狗宝宝的称呼:puppy。
特征定义中的特征约束
有时,我们会需要让某个特征 A 能使用另一个特征 B 的功能(另一种形式的特征约束),这种情况下,不仅仅要为类型实现特征 A,还要为类型实现特征 B 才行,这就是 supertrait
例如有一个特征 OutlinePrint
,它有一个方法,能够对当前的实现类型进行格式化输出:
use std::fmt::Display;
trait OutlinePrint: Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {} *", output);
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
- 这里有一个眼熟的语法:
OutlinePrint: Display
,感觉很像之前讲过的特征约束,只不过用在了特征定义中而不是函数的参数中, - 是的,在某种意义上来说,这和特征约束非常类似,都用来说明一个特征需要实现另一个特征,
- 这里就是:如果你想要实现
OutlinePrint
特征,首先你需要实现Display
特征。
在外部类型上实现外部特征
在特征章节中,有提到孤儿规则,简单来说,就是特征或者类型必需至少有一个是本地的,才能在此类型上定义特征。
这里提供一个办法来绕过孤儿规则,那就是使用newtype 模式,简而言之:就是为一个元组结构体创建新类型。该元组结构体封装有一个字段,该字段就是希望实现特征的具体类型。
该封装类型是本地的,因此我们可以为此类型实现外部的特征。
newtype
不仅仅能实现以上的功能,而且它在运行时没有任何性能损耗,因为在编译期,该类型会被自动忽略。
下面来看一个例子,我们有一个动态数组类型: Vec<T>
,它定义在标准库中,还有一个特征 Display
,它也定义在标准库中,如果没有 newtype
,我们是无法为 Vec<T>
实现 Display
的
error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
--> src/main.rs:5:1
|
5 | impl<T> std::fmt::Display for Vec<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------
| | |
| | Vec is not defined in the current crate
| impl doesn't use only types from inside the current crate
|
= note: define and implement a trait or new type instead
编译器给了我们提示: define and implement a trait or new type instead
,重新定义一个特征,或者使用 new type
,前者当然不可行,那么来试试后者:
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(", "))
}
}
fn main() {
let w = Wrapper(vec![String::from("hello"), String::from("world")]);
println!("w = {}", w);
}
其中,struct Wrapper(Vec<String>)
就是一个元组结构体,它定义了一个新类型 Wrapper
,代码很简单,相信大家也很容易看懂。
既然 new type
有这么多好处,它有没有不好的地方呢?答案是肯定的。注意到我们怎么访问里面的数组吗?self.0.join(", ")
,是的,很啰嗦,因为需要先从 Wrapper
中取出数组: self.0
,然后才能执行 join
方法。
类似的,任何数组上的方法,你都无法直接调用,需要先用 self.0
取出数组,然后再进行调用。
当然,解决办法还是有的,要不怎么说 Rust 是极其强大灵活的编程语言!Rust 提供了一个特征叫 Deref
,实现该特征后,可以自动做一层类似类型转换的操作,可以将 Wrapper
变成 Vec<String>
来使用。这样就会像直接使用数组那样去使用 Wrapper
,而无需为每一个操作都添加上 self.0
。
同时,如果不想 Wrapper
暴露底层数组的所有方法,我们还可以为 Wrapper
去重载这些方法,实现隐藏的目的。