'Deref'强制转换

'Deref'强制转换

标准库提供了一个特殊的特征，Deref。它通常用于重载 * ，取消引用运算符：

use std::ops::Deref;

struct DerefExample<T> {
value: T,
}

impl<T> Deref for DerefExample<T> {
type Target = T;

fn deref(&self) -> &T {
&self.value
}
}

fn main() {
let x = DerefExample { value: 'a' };
assert_eq!('a', *x);
}

这用于编写自定义指针类型。然而，有一个与 Deref 相关的语言特征：‘deref 强制转换’。规则是这样的：如果你有一个类型 U，它实现 Deref<Target=T>，&U 的值自动强制转换为 &T。这里有一个例子：

fn foo(s: &str) {
// borrow a string for a second
}

// String implements Deref<Target=str>
let owned = "Hello".to_string();

// therefore, this works:
foo(&owned);

在一个值前使用 & 需要一个引用。所以 owned 是一个 String，&owned 是一个 &String，并且由于 impl Deref<Target=str> for String，&String 参考传入函数 foo() 的 &str。

就这样。这条规则是 Rust 为你自动转换的少有的几处之一，但它增加了很大的灵活性。例如，类型 Rc<T> 实现 Deref<Target=T>，所以它的工作原理如下：

use std::rc::Rc;

fn foo(s: &str) {
// borrow a string for a second
}

// String implements Deref<Target=str>
let owned = "Hello".to_string();
let counted = Rc::new(owned);

// therefore, this works:
foo(&counted);

所有我们所做的就是把我们的 String 封装到 Rc<T>。但是我们现在可以把 Rc<String> 传到任何有 String 的地方。foo 的声明并没有改变，但能实现与其它类型一样的功能。这个例子有两个转换：Rc<String> 转换为 String，然后 String 转换为 &str。Rust 会这样做尽可能多的次数直到类型匹配。　　　　

标准库提供的另一个很常见的实现是：

fn foo(s: &[i32]) {
// borrow a slice for a second
}

// Vec<T> implements Deref<Target=[T]>
let owned = vec![1, 2, 3];

foo(&owned);

向量可以取消对程序片的引用。

Deref 和方法调用

Deref 调用方法时也起作用。换句话说，Rust 有相同的两件事：

struct Foo;

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

let f = Foo;

f.foo();

尽管 f 不是引用，但是函数 foo 中传入 &self 就会起作用。这是因为这些东西是相同的：

f.foo();
(&f).foo();
(&&f).foo();
(&&&&&&&&f).foo();

&&&&&&&&&&&&&&&&Foo 类型的值仍然可以有定义在 Foo 上的方法，因为编译器会插入许多 操作只要程序正确运行。因为它的插入 s，就要使用 Deref。