Rust 解引用

自动解引用的用处

用Rc这个“智能指针”举例。Rc实现了Deref:

implSized> Deref for Rc {
    type Target = T;
 
    #[inline(always)]
    fn deref(&self) -> &T {
        &self.inner().value
    }
}

它的 Target 类型是它的泛型参数 T。这么设计有什么好处呢，我们看下面的用法：

use std::rc::Rc;
 
fn main() {
    let s = Rc::new(String::from("hello"));
    println!("{:?}", s.bytes());
}

我们创建了一个指向String类型的Rc指针，并调用了bytes()方法。这里是不是有点奇怪？

Rc类型本身并没有bytes()方法，所以编译器会尝试自动deref，试试s.deref().bytes()。String类型其实也没有bytes()方法，但是String可以继续deref，于是再试试s.deref().deref().bytes()。这次在str类型中，找到了bytes()方法，于是编译通过。

我们实际上通过Rc类型的变量，调用了str类型的方法，让这个智能指针像个透明的存在。这就是自动Deref的意义。

实际上以下写法在编译器看起来是一样的：

use std::rc::Rc;
use std::ops::Deref;
 
fn main() {
    let s = Rc::new(String::from("hello"));
 
    println!("length: {}", s.len());
    println!("length: {}", s.deref().len());
    println!("length: {}", s.deref().deref().len());
 
    println!("length: {}", (*s).len());
    println!("length: {}", (&*s).len());
    println!("length: {}", (&**s).len());
}

注意：我们可以写let p = &*s;，它可以创建一个指向内部String的指针。这种写法不等于

let tmp = *s;
let x = &tmp;

因为这个tmp的存在，它表达的是move语义。也不等于

let x = &{*s};

这个大括号引入了新的 scope，同样也是move语义。

有时候需要手动处理

如果说，智能指针中的方法与它内部成员的方法冲突了怎么办呢？编译器会优先调用当前最匹配的类型，而不会执行自动 deref，这种情况下，我们就只能手动 deref 来表达我们的需求了。

比如说，Rc类型和String类型都有clone方法，但是它们执行的任务不同。Rc::clone()做的是把引用计数指针复制一份，把引用计数加1。String::clone()做的是把字符串复制一份。示例如下：

use std::rc::Rc;
use std::ops::Deref;
 
fn type_of(_: ()) { }
 
fn main() {
    let s = Rc::new(Rc::new(String::from("hello")));
 
    let s1 = s.clone();        // (1)
    //type_of(s1);
    let ps1 = (*s).clone();    // (2)
    //type_of(ps1);
    let pps1 = (**s).clone();  // (3)
    //type_of(pps1);
}

在以上的代码中，位置(1)处，s1的类型为Rc>，位置(2)处，ps1的类型为Rc，位置(3)处，pps1的类型为String。

一般情况，在函数调用的时候，编译器会帮我们尝试自动解引用。但在其它情况下，编译器不会为我们自动插入自动解引用的代码。比如，以String和 &str类型为例：

fn main() {
  let s = String::new();
  match &s {
    "" => {}
    _ => {}
  }
}

这段代码编译会发生错误，错误信息为：

mismatched types:
 expected `&collections::string::String`,
    found `&'static str`

match 后面的变量类型是 &String，匹配分支的变量类型为 &str，这种情况下就需要我们手工完成类型转换了。为了将&String类型转换为&str类型，手工类型转换的话有哪些办法呢？

参考答案：

1. match s.as_ref()。 这个方法是最通用最直观的办法。
2. match s.borrow()。为了使用这个方法，我们必须引入Borrow trait。也就是需要加上代码use std::borrow::Borrow;。
3. match s.deref()。 这个方法通过主动调用deref()方法，达到类型转换的目的。此时我们需要引入Deref trait方可以通过编译，即加上代码use std::ops::Deref;。
4. match &*s。 我们可以通过*s运算符，也可以强制调用deref()方法，与上面的做法一样。
5. match &s[..]。这个方案也是可以的，这里利用了String重载的Index操作。

总结

Rust中允许一部分运算符可以由用户自定义行为，类似其它语言中的“操作符重载”。其中解引用是一个非常重要的操作符，它允许重载。

而需要提醒大家注意的是，取引用操作符，如 & &mut 等，是不允许重载的。因此，取引用& 和 解引用* 并非对称互补关系。*&T的类型一定是T，而&*T 的类型未必就是 T。

更重要的是，读者需要理解，在某些情况下，编译器帮我们插入了自动 deref 的调用，简化代码。