使用 Deref Trait 将智能指针视为常规引用

Listing 15-7 和 Listing 15-6 之间的主要区别在于，这里我们将 y 设置为 Box<T> 的一个实例，它指向 x 的复制值，而不是指向 x 值的引用。在最后的断言中，我们可以使用解引用运算符来追踪 Box<T> 的指针，就像当 y 是引用时我们所做的那样。接下来，我们将通过定义我们自己的类型来探索 Box<T> 的特殊之处，使其能够让我们使用解引用运算符。

定义我们自己的智能指针

让我们构建一个类似于标准库提供的 Box<T> 类型的智能指针，以体验智能指针默认情况下与引用有何不同。然后我们将看看如何添加使用解引用运算符的能力。

Box<T> 类型最终被定义为一个带有一个元素的元组结构体，因此 Listing 15-8 以相同的方式定义了 MyBox<T> 类型。我们还将定义一个 new 函数，以匹配 Box<T> 上定义的 new 函数。

文件名：src/main.rs

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {}

Listing 15-8：定义 MyBox<T> 类型

我们定义了一个名为 MyBox 的结构体，并声明了一个泛型参数 T，因为我们希望我们的类型能够保存任何类型的值。MyBox 类型是一个带有一个 T 类型元素的元组结构体。MyBox::new 函数接受一个 T 类型的参数，并返回一个持有传入值的 MyBox 实例。

让我们尝试将 Listing 15-7 中的 main 函数添加到 Listing 15-8，并将其更改为使用我们定义的 MyBox<T> 类型而不是 Box<T>。Listing 15-9 中的代码将无法编译，因为 Rust 不知道如何解引用 MyBox。

文件名：src/main.rs

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

Listing 15-9：尝试以我们使用引用和 Box<T> 的相同方式使用 MyBox<T>

这是产生的编译错误

$ cargo run
   Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
  --> src/main.rs:14:19
   |
14 |     assert_eq!(5, *y);
   |                   ^^

For more information about this error, try `rustc --explain E0614`.
error: could not compile `deref-example` (bin "deref-example") due to 1 previous error

我们的 MyBox<T> 类型无法被解引用，因为我们没有在我们的类型上实现该能力。要启用使用 * 运算符进行解引用，我们实现 Deref trait。

通过实现 `Deref` Trait 将类型视为引用

如第 10 章的 “为类型实现 Trait”部分，要实现 trait，我们需要为 trait 的必需方法提供实现。标准库提供的 Deref trait 要求我们实现一个名为 deref 的方法，该方法借用 self 并返回对内部数据的引用。Listing 15-10 包含要添加到 MyBox 定义的 Deref 的实现

文件名：src/main.rs

use std::ops::Deref;

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

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

Listing 15-10：在 MyBox<T> 上实现 Deref

type Target = T; 语法为 Deref trait 定义了一个关联类型以供使用。关联类型是一种稍微不同的声明泛型参数的方式，但你现在无需担心它们；我们将在第 20 章中更详细地介绍它们。

我们用 &self.0 填充 deref 方法的主体，以便 deref 返回对我们想要用 * 运算符访问的值的引用；回想一下第 5 章的 “使用无名字段的元组结构体来创建不同类型”部分，.0 访问元组结构体中的第一个值。现在 Listing 15-9 中在 MyBox<T> 值上调用 * 的 main 函数可以编译了，并且断言也通过了！

如果没有 Deref trait，编译器只能解引用 & 引用。deref 方法使编译器能够接受任何实现了 Deref 的类型的值，并调用 deref 方法来获取编译器知道如何解引用的 & 引用。

当我们在 Listing 15-9 中输入 *y 时，Rust 实际上在幕后运行了这段代码

*(y.deref())

Rust 将 * 运算符替换为对 deref 方法的调用，然后再进行普通的解引用，因此我们不必考虑是否需要调用 deref 方法。这个 Rust 特性让我们编写的代码在无论是使用常规引用还是实现 Deref 的类型时，功能都相同。

deref 方法返回对值的引用，以及 *(y.deref()) 中括号外的普通解引用仍然是必要的，原因与所有权系统有关。如果 deref 方法直接返回该值而不是对值的引用，则该值将从 self 中移出。在这种情况下，或者在我们使用解引用运算符的大多数情况下，我们不想取得 MyBox<T> 内部值的所有权。

注意，每次我们在代码中使用 * 时，* 运算符只会被替换为对 deref 方法的调用，然后再调用一次 * 运算符。由于 * 运算符的替换不会无限递归，我们最终得到 i32 类型的数据，这与 Listing 15-9 中 assert_eq! 中的 5 相匹配。

函数和方法中的隐式解引用强制转换

解引用强制转换将对实现了 Deref trait 的类型的引用转换为对另一种类型的引用。例如，解引用强制转换可以将 &String 转换为 &str，因为 String 实现了 Deref trait，使其返回 &str。解引用强制转换是 Rust 对函数和方法的参数执行的一种便利操作，并且仅适用于实现了 Deref trait 的类型。当我们传递对特定类型值的引用作为函数或方法的参数时，而该参数类型与函数或方法定义中的参数类型不匹配时，它会自动发生。对 deref 方法的一系列调用将我们提供的类型转换为参数需要的类型。

将解引用强制转换添加到 Rust 中，是为了让编写函数和方法调用的程序员不必添加那么多带有 & 和 * 的显式引用和解引用。解引用强制转换特性还使我们能够编写更多可以用于引用或智能指针的代码。

为了看到解引用强制转换的实际效果，让我们使用我们在 Listing 15-8 中定义的 MyBox<T> 类型以及我们在 Listing 15-10 中添加的 Deref 的实现。Listing 15-11 显示了一个具有字符串切片参数的函数的定义

文件名：src/main.rs

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {}

Listing 15-11：一个 hello 函数，其参数 name 的类型为 &str

我们可以使用字符串切片作为参数调用 hello 函数，例如 hello("Rust");。解引用强制转换使得可以使用对 MyBox<String> 类型值的引用来调用 hello，如 Listing 15-12 所示

文件名：src/main.rs

use std::ops::Deref;

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

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

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m);
}

Listing 15-12：使用对 MyBox<String> 值的引用调用 hello，这由于解引用强制转换而起作用

这里我们使用参数 &m 调用 hello 函数，它是对 MyBox<String> 值的引用。由于我们在 Listing 15-10 中在 MyBox<T> 上实现了 Deref trait，Rust 可以通过调用 deref 将 &MyBox<String> 转换为 &String。标准库在 String 上提供了 Deref 的实现，该实现返回字符串切片，这在 Deref 的 API 文档中。Rust 再次调用 deref 以将 &String 转换为 &str，这与 hello 函数的定义匹配。

如果 Rust 没有实现解引用强制转换，我们将不得不编写 Listing 15-13 中的代码，而不是 Listing 15-12 中的代码，以使用 &MyBox<String> 类型的值调用 hello。

文件名：src/main.rs

use std::ops::Deref;

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

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

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&(*m)[..]);
}

Listing 15-13：如果 Rust 没有解引用强制转换，我们将不得不编写的代码

(*m) 将 MyBox<String> 解引用为 String。然后 & 和 [..] 获取 String 的字符串切片，该切片等于整个字符串，以匹配 hello 的签名。如果没有解引用强制转换，这段代码将更难阅读、编写和理解，因为它涉及到所有这些符号。解引用强制转换允许 Rust 为我们自动处理这些转换。

当为涉及的类型定义了 Deref trait 时，Rust 将分析这些类型并尽可能多次使用 Deref::deref 以获得与参数类型匹配的引用。需要插入 Deref::deref 的次数在编译时就已确定，因此利用解引用强制转换不会有运行时性能损失！

解引用强制转换如何与可变性交互

类似于你如何使用 Deref trait 重写不可变引用上的 * 运算符，你可以使用 DerefMut trait 重写可变引用上的 * 运算符。

当 Rust 在以下三种情况下找到类型和 trait 实现时，它会执行解引用强制转换

当 T: Deref<Target=U> 时，从 &T 到 &U
当 T: DerefMut<Target=U> 时，从 &mut T 到 &mut U
当 T: Deref<Target=U> 时，从 &mut T 到 &U

前两种情况彼此相同，只是第二种实现了可变性。第一种情况说明，如果你有一个 &T，并且 T 实现了到某种类型 U 的 Deref，你可以透明地获得一个 &U。第二种情况说明，相同的解引用强制转换发生在可变引用上。

第三种情况比较棘手：Rust 也会将可变引用强制转换为不可变引用。但是反过来是不可能的：不可变引用永远不会强制转换为可变引用。由于借用规则，如果你有一个可变引用，那么该可变引用必须是该数据的唯一引用（否则，程序将无法编译）。将一个可变引用转换为一个不可变引用永远不会破坏借用规则。将不可变引用转换为可变引用将要求初始的不可变引用是该数据的唯一不可变引用，但是借用规则不能保证这一点。因此，Rust 不能假设将不可变引用转换为可变引用是可能的。

Rust 编程语言