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

通过 `Deref` Trait 将智能指针视为常规引用

实现 Deref trait 可以让你自定义解引用运算符 * （不要与乘法或 glob 运算符混淆）的行为。通过以某种方式实现 Deref，使得智能指针可以像常规引用一样被对待，你可以编写针对引用操作的代码，并且也可以将这些代码与智能指针一起使用。

我们首先看看解引用运算符是如何与常规引用一起工作的。然后我们将尝试定义一个自定义类型，该类型的行为类似于 Box<T>，并查看为什么解引用运算符在我们的新定义类型上不像引用那样工作。我们将探索如何实现 Deref trait 使智能指针能够以类似于引用的方式工作。然后，我们将了解 Rust 的解引用强制转换功能以及它如何让我们使用引用或智能指针。

注意：我们即将构建的 MyBox<T> 类型与真正的 Box<T> 之间有一个很大的区别：我们的版本不会将数据存储在堆上。我们将此示例的重点放在 Deref 上，因此数据的实际存储位置不如指针行为重要。

跟踪指针到值

常规引用是一种指针类型，而考虑指针的一种方式是将其视为指向存储在其他位置的值的箭头。在列表 15-6 中，我们创建了一个对 i32 值的引用，然后使用解引用运算符来跟踪引用到该值

文件名：src/main.rs

fn main() {
    let x = 5;
    let y = &x;

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

列表 15-6：使用解引用运算符来跟踪到 i32 值的引用

变量 x 保存一个 i32 值 5。我们将 y 设置为对 x 的引用。我们可以断言 x 等于 5。但是，如果我们想断言 y 中的值，则必须使用 *y 来跟踪引用到它指向的值（因此是解引用），以便编译器可以比较实际值。一旦我们解引用 y，我们就可以访问 y 指向的整数值，以便我们可以将其与 5 进行比较。

如果我们尝试编写 assert_eq!(5, y);，我们将收到此编译错误

$ cargo run
   Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0277]: can't compare `{integer}` with `&{integer}`
 --> src/main.rs:6:5
  |
6 |     assert_eq!(5, y);
  |     ^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
  |
  = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
  = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)

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

不允许比较数字和对数字的引用，因为它们是不同的类型。我们必须使用解引用运算符来跟踪引用到它指向的值。

像引用一样使用 `Box<T>`

我们可以重写列表 15-6 中的代码以使用 Box<T> 而不是引用；在列表 15-7 中对 Box<T> 使用的解引用运算符与在列表 15-6 中对引用使用的解引用运算符的功能相同

文件名：src/main.rs

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

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

列表 15-7：对 Box<i32> 使用解引用运算符

列表 15-7 和列表 15-6 之间的主要区别在于，这里我们将 y 设置为 Box<T> 的实例，该实例指向 x 的复制值，而不是指向 x 值的引用。在最后一个断言中，我们可以使用解引用运算符来跟踪 Box<T> 的指针，其方式与 y 为引用时相同。接下来，我们将通过定义我们自己的类型来探索 Box<T> 的特殊之处，这使我们能够使用解引用运算符。

定义我们自己的智能指针

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

Box<T> 类型最终定义为具有一个元素的元组结构，因此列表 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() {}

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

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

让我们尝试将列表 15-7 中的 main 函数添加到列表 15-8 中，并将其更改为使用我们定义的 MyBox<T> 类型而不是 Box<T>。列表 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);
}

列表 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 将类型视为引用

如“在类型上实现 Trait”第 10 章的节中所讨论的那样，要实现一个 trait，我们需要为 trait 的必需方法提供实现。由标准库提供的 Deref trait 要求我们实现一个名为 deref 的方法，该方法借用 self 并返回对内部数据的引用。列表 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);
}

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

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

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

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

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

*(y.deref())

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

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

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

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

向 Rust 添加解引用强制转换是为了使编写函数和方法调用的程序员无需添加太多使用 & 和 * 的显式引用和解引用。解引用强制转换功能还使我们可以编写更多可以用于引用或智能指针的代码。

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

文件名：src/main.rs

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

fn main() {}

列表 15-11：具有类型为 &str 的参数 name 的 hello 函数

我们可以使用字符串切片作为参数来调用 hello 函数，例如 hello("Rust");。解引用强制转换使可以使用对类型为 MyBox<String> 的值的引用来调用 hello，如列表 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);
}

列表 15-12：使用对 MyBox<String> 值的引用调用 hello，由于解引用强制转换，该调用有效

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

如果 Rust 没有实现解引用强制转换，我们必须编写列表 15-13 中的代码，而不是列表 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)[..]);
}

列表 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 程序设计语言

跟踪指针到值

像引用一样使用 Box<T>

定义我们自己的智能指针

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

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

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