将智能指针视为常规引用
实现 Deref 特性允许你自定义 解引用操作符 * 的行为（不要与乘法或通配符操作符混淆）。通过以这种方式实现 Deref，使得智能指针可以像普通引用一样被处理，你可以编写操作引用的代码，并且也可以用这些代码处理智能指针。
让我们首先看看解引用运算符如何与常规引用一起工作。
然后，我们将尝试定义一个像Box<T>一样行为的自定义类型，并看看为什么
解引用运算符在我们新定义的类型上不像引用那样工作。我们将探讨实现Deref特征如何使
智能指针能够以类似于引用的方式工作。然后，我们将看看
Rust的解引用强制转换特性以及它如何让我们使用引用或
智能指针。
跟踪引用到值
一个常规引用是一种指针，而理解指针的一种方式是将其视为指向存储在其他地方的值的箭头。在示例 15-6 中，我们创建了一个指向 i32 值的引用，然后使用解引用运算符来跟踪引用到值。
fn main() { let x = 5; let y = &x; assert_eq!(5, x); assert_eq!(5, *y); }
i32 value变量 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 中对引用使用的解引用运算符功能相同。
fn main() { let x = 5; let y = Box::new(x); assert_eq!(5, x); assert_eq!(5, *y); }
Box<i32>列表 15-7 和列表 15-6 之间的主要区别在于，这里我们将 y 设置为指向 x 值的副本的 box 实例，而不是指向 x 值的引用。在最后一个断言中，我们可以使用解引用运算符来跟踪 box 的指针，就像 y 是引用时我们所做的那样。接下来，我们将通过定义我们自己的 box 类型来探讨 Box<T> 的特殊之处，这使我们能够使用解引用运算符。
定义我们自己的智能指针
让我们构建一个类似于标准库提供的Box<T>类型的包装类型，以体验智能指针类型默认情况下与引用的行为有何不同。然后，我们将看看如何添加使用解引用运算符的能力。
注意：我们即将构建的 MyBox<T> 类型和真正的 Box<T> 之间有一个很大的区别：我们的版本不会将数据存储在堆上。我们在这个例子中关注的是 Deref，因此数据实际存储的位置不如指针行为重要。
Box<T> 类型最终被定义为一个包含一个元素的元组结构体，因此 列表 15-8 以相同的方式定义了一个 MyBox<T> 类型。我们还将定义一个 new 函数，以匹配在 Box<T> 上定义的 new 函数。
struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } fn main() {}
MyBox<T> type我们定义了一个名为 MyBox 的结构体，并声明了一个泛型参数 T，因为
我们希望我们的类型能够持有任何类型的值。 MyBox 类型是一个元组结构体
，包含一个类型为 T 的元素。 MyBox::new 函数接受一个类型为 T 的参数
并返回一个持有传入值的 MyBox 实例。
让我们尝试将清单 15-7 中的 main 函数添加到清单 15-8 中，并
将其更改为使用我们定义的 MyBox<T> 类型而不是 Box<T>。 清单 15-9 中的代码将无法编译，因为 Rust 不知道如何对 MyBox 进行解引用。
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);
}MyBox<T> in the same way we used references and Box<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 特性。
实现 Deref 特性
如“在类型上实现特征”在
第 10 章中所述，要实现一个特征，我们需要为该特征的必需方法提供实现。标准库提供的Deref特征要求我们实现一个名为deref的方法，该方法借用self并返回对内部数据的引用。列表 15-10 包含了为MyBox<T>定义添加的Deref实现。
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); }
Deref on MyBox<T>type Target = T; 语法为 Deref 特性定义了一个关联类型。关联类型是一种声明泛型参数的略有不同的方式，但你现在不需要担心它们；我们将在第 20 章中详细讨论。
我们将 deref 方法的主体填充为 &self.0，以便 deref
返回一个引用，该引用指向我们希望用 * 操作符访问的值；
回想一下在第 5 章的 “使用元组结构体创建不同类型的实例” 中，.0 用于访问元组结构体中的第一个值。
现在，清单 15-9 中调用 * 操作符的 MyBox<T> 值的 main 函数可以编译，并且断言通过！
没有 Deref 特性，编译器只能对 & 引用进行解引用。
deref 方法使编译器能够获取任何实现了 Deref 的类型的值，并调用 deref 方法以获得一个它知道如何解引用的引用。
当我们输入 *y 在清单 15-9 中时，实际上 Rust 在幕后运行了这段代码：
*(y.deref())Rust 用对 deref 方法的调用和随后的简单解引用替换了 * 操作符，这样我们就不必考虑是否需要调用 deref 方法。这个 Rust 特性让我们可以编写功能相同的代码，无论我们使用的是普通引用还是实现了 Deref 的类型。
deref 方法返回一个值的引用，而 *(y.deref()) 中括号外的普通解引用仍然必要，这与所有权系统有关。如果 deref 方法直接返回值而不是值的引用，那么值将从 self 中移出。在这种情况下，以及在大多数使用解引用操作符的情况下，我们不希望获取 MyBox<T> 内部值的所有权。
请注意，每次我们在代码中使用 * 时，* 操作符都会被替换为对 deref 方法的调用，然后是对 * 操作符的调用，但仅一次。因为 * 操作符的替换不会无限递归，我们最终得到的是 i32 类型的数据，这与列表 15-9 中 assert_eq! 中的 5 匹配。
在函数和方法中使用 Deref 强制转换
Deref 强制转换 将对实现了 Deref 特性的类型的引用转换为对另一种类型的引用。例如，Deref 强制转换可以将 &String 转换为 &str，因为 String 实现了 Deref 特性，使其返回 &str。Deref 强制转换是 Rust 在函数和方法的参数上执行的一种便捷操作，它仅适用于实现了 Deref 特性的类型。当我们传递对特定类型值的引用作为参数给函数或方法时，如果该参数类型与函数或方法定义中的参数类型不匹配，Deref 强制转换会自动发生。通过一系列调用 deref 方法，可以将我们提供的类型转换为参数所需的类型。
Deref 强制转换被添加到 Rust 中，以便编写函数和方法调用的程序员不需要添加那么多显式的引用和解引用的 & 和 *。Deref 强制转换特性还让我们能够编写更多可以适用于引用或智能指针的代码。
为了看到解引用强制转换的效果，让我们使用我们在清单 15-8 中定义的 MyBox<T> 类型以及我们在清单 15-10 中添加的 Deref 实现。清单 15-11 显示了一个具有字符串切片参数的函数的定义。
fn hello(name: &str) { println!("Hello, {name}!"); } fn main() {}
hello function that has the parameter name of type &str我们可以用字符串切片作为参数调用 hello 函数，例如 hello("Rust");。解引用强制转换使得我们可以用 MyBox<String> 类型值的引用调用 hello，如清单 15-12 所示。
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); }
hello with a reference to a MyBox<String> value, which works because of deref coercion这里我们调用 hello 函数，参数为 &m，这是对 MyBox<String> 值的引用。因为我们在清单 15-10 中为 MyBox<T> 实现了 Deref 特性，Rust 可以通过调用 deref 将 &MyBox<String> 转换为 &String。标准库为 String 提供了一个返回字符串切片的 Deref 实现，这在 Deref 的 API 文档中有说明。Rust 再次调用 deref 将 &String 转换为 &str，这与 hello 函数的定义相匹配。
如果 Rust 没有实现解引用强制，我们就必须编写列表 15-13 中的代码，而不是列表 15-12 中的代码，以使用类型为 &MyBox<String> 的值调用 hello。
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)[..]); }
(*m) 将 MyBox<String> 解引用为 String。然后，& 和 [..] 从 String 中获取一个等于整个字符串的字符串切片，以匹配 hello 的签名。没有解引用强制转换的代码由于涉及这些符号而更难阅读、编写和理解。解引用强制转换允许 Rust 自动为我们处理这些转换。
当为涉及的类型定义了Deref特征时，Rust将分析类型并根据需要多次使用Deref::deref以获取与参数类型匹配的引用。需要插入Deref::deref的次数在编译时确定，因此利用解引用强制转换不会带来运行时性能损失！
处理可变引用的 Deref 强制转换
类似于您使用 Deref 特性来重载不可变引用上的 * 操作符，您可以使用 DerefMut 特性来重载可变引用上的 * 操作符。
Rust 在三种情况下发现类型和特征实现时会进行解引用强制：
- 从
&T到&U当T: Deref<Target=U> - 从
&mut T到&mut U当T: DerefMut<Target=U> - 从
&mut T到&U当T: Deref<Target=U>
前两个案例相同，只是第二个实现了可变性。
第一个案例说明，如果你有一个 &T，并且 T 实现了到某种类型 U 的 Deref，你可以透明地获得一个 &U。第二个案例说明，对于可变引用，同样的解引用强制转换也会发生。
第三种情况更复杂：Rust 还会将可变引用强制转换为不可变引用。但相反的情况不可能：不可变引用永远不会强制转换为可变引用。由于借用规则，如果你有一个可变引用，那么这个可变引用必须是该数据的唯一引用（否则，程序将无法编译）。将一个可变引用转换为一个不可变引用永远不会违反借用规则。将不可变引用转换为可变引用需要初始的不可变引用是该数据的唯一不可变引用，但借用规则不能保证这一点。因此，Rust 不能假设将不可变引用转换为可变引用是可能的。