The Rust Programming Language

使用 Box<T> 指向堆上的数据

最直接的智能指针是box，其类型写作Box<T>。Box允许你将数据存储在堆上而不是栈上。留在栈上的是指向堆数据的指针。参阅第4章以回顾栈和堆之间的区别。

Boxes 不会有性能开销，除了将数据存储在堆上而不是栈上。但它们也没有太多额外的功能。你最常在以下情况下使用它们：

• 当你有一个在编译时无法确定大小的类型，并且你想在需要确切大小的上下文中使用该类型的值时，
• 当你有大量的数据并且你想转移所有权，但确保在这样做时数据不会被复制，
• 当你想要拥有一个值，而你只关心它是一个实现了特定特征的类型，而不是特定的类型时，

我们将通过“使用Box启用递归类型”来演示第一种情况。在第二种 情况下，转移大量数据的所有权可能需要很长时间 因为数据会在栈上被复制。为了在这种情况下提高性能，我们可以将大量数据存储在堆上的一个Box中。然后， 只有少量的指针数据会在栈上被复制，而它引用的数据会保持在堆上的一个位置。第三种情况被称为trait对象，第18章的“使用允许不同类型的值的trait对象”专门讨论了这个主题。 所以你在这里学到的内容在那一节中也会再次应用！

使用 Box<T> 在堆上存储数据

在我们讨论 Box<T> 的堆存储用例之前，我们将介绍其语法以及如何与存储在 Box<T> 中的值进行交互。

列表 15-1 显示了如何使用一个盒子在堆上存储一个 i32 值。

fn main() {
    let b = Box::new(5);
    println!("b = {b}");
}

我们定义变量b具有指向值5的Box，该值分配在堆上。此程序将打印b = 5；在这种情况下，我们可以像访问栈上的数据一样访问盒中的数据。就像任何拥有值一样，当盒超出作用域时，如b在main结束时那样，它将被释放。释放会同时发生于盒（存储在栈上）和它指向的数据（存储在堆上）。

将单个值放在堆上并不是很有用，所以你不会经常以这种方式单独使用盒子。像单个i32这样的值，默认存储在栈上，在大多数情况下更为合适。让我们来看一个例子，如果没有盒子，我们是无法定义这些类型的。

使用 Box 启用递归类型

一个递归类型的值可以包含另一个相同类型的值作为其自身的一部分。递归类型存在问题，因为Rust需要在编译时知道一个类型占用多少空间。然而，递归类型值的嵌套理论上可以无限继续，所以Rust无法知道该值需要多少空间。因为盒子有一个已知的大小，我们可以通过在递归类型定义中插入一个盒子来启用递归类型。

作为递归类型的一个例子，让我们探讨一下cons list。这是一种在函数式编程语言中常见的数据类型。我们将定义的 cons list 类型除了递归之外非常直接；因此，我们将在示例中使用的概念在涉及更复杂递归类型的情况时也会很有用。

关于 Cons 列表的更多信息

一个 cons list 是一种来自 Lisp 编程语言及其方言的数据结构，由嵌套的对组成，是 Lisp 版本的链表。它的名称来源于 Lisp 中的 cons 函数（即 构造函数 的缩写），该函数从其两个参数构建一个新的对。通过在由一个值和另一个对组成的对上调用 cons，我们可以构建由递归对组成的 cons 列表。

例如，以下是一个包含列表 1, 2, 3 的 cons 列表的伪代码表示，每对元素用括号表示：

(1, (2, (3, Nil)))

cons 列表中的每个项包含两个元素：当前项的值和下一个项。列表中的最后一项仅包含一个名为 Nil 的值，没有下一个项。cons 列表是通过递归调用 cons 函数生成的。递归的基本情况的规范名称是 Nil。请注意，这与第 6 章中讨论的“null”或“nil”概念不同，后者表示无效或不存在的值。

cons 列表在 Rust 中并不是常用的数据结构。大多数时候，当你在 Rust 中有一系列项目时，Vec<T> 是更好的选择。其他更复杂的递归数据类型 确实 在各种情况下有用，但通过在本章中从 cons 列表开始，我们可以探索盒子如何让我们定义递归数据类型而不受太多干扰。

列表 15-2 包含一个 cons 列表的枚举定义。请注意，此代码还不能编译，因为 List 类型没有已知的大小，我们将对此进行演示。

enum List {
    Cons(i32, List),
    Nil,
}

fn main() {}

使用 List 类型来存储列表 1, 2, 3 将如清单 15-3 所示的代码。

enum List {
    Cons(i32, List),
    Nil,
}

// --snip--

use crate::List::{Cons, Nil};

fn main() {
    let list = Cons(1, Cons(2, Cons(3, Nil)));
}

第一个 Cons 值持有 1 和另一个 List 值。这个 List 值是 另一个 Cons 值，持有 2 和另一个 List 值。这个 List 值 是另一个 Cons 值，持有 3 和一个 List 值，最终是 Nil，这个非递归变体表示列表的结束。

如果我们尝试编译列表 15-3 中的代码，我们会得到列表 15-4 中所示的错误。

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0072]: recursive type `List` has infinite size
 --> src/main.rs:1:1
  |
1 | enum List {
  | ^^^^^^^^^
2 |     Cons(i32, List),
  |               ---- recursive without indirection
  |
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
  |
2 |     Cons(i32, Box<List>),
  |               ++++    +

error[E0391]: cycle detected when computing when `List` needs drop
 --> src/main.rs:1:1
  |
1 | enum List {
  | ^^^^^^^^^
  |
  = note: ...which immediately requires computing when `List` needs drop again
  = note: cycle used when computing whether `List` needs drop
  = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information

Some errors have detailed explanations: E0072, E0391.
For more information about an error, try `rustc --explain E0072`.
error: could not compile `cons-list` (bin "cons-list") due to 2 previous errors

错误显示这种类型“具有无限大小。”原因是我们在定义List时使用了一个递归的变体：它直接持有另一个自身的值。因此，Rust 无法确定存储一个List值需要多少空间。让我们分析为什么会发生这个错误。首先，我们将看看 Rust 是如何决定存储一个非递归类型值所需的空间。

计算非递归类型的大小

回忆我们在第 6 章讨论枚举定义时，在列表 6-2 中定义的 Message 枚举：

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

为了确定为 Message 值分配多少空间，Rust 会遍历每个变体以查看哪个变体需要最多的空间。Rust 发现 Message::Quit 不需要任何空间，Message::Move 需要足够的空间来存储两个 i32 值，依此类推。因为只有一个变体会被使用，所以 Message 值需要的最大空间就是存储其最大变体所需的空间。

将此与 Rust 尝试确定像 Listing 15-2 中的 List 枚举这样的递归类型需要多少空间时发生的情况进行对比。编译器首先查看 Cons 变体，它包含一个类型为 i32 的值和一个类型为 List 的值。因此，Cons 需要的空间量等于 i32 的大小加上 List 的大小。为了确定 List 类型需要多少内存，编译器查看变体，从 Cons 变体开始。Cons 变体包含一个类型为 i32 的值和一个类型为 List 的值，这个过程会无限继续，如图 15-1 所示。

图15-1：由无限的 Cons 变体组成的无限 List

使用 Box<T> 获取具有已知大小的递归类型

因为 Rust 无法确定为递归定义的类型分配多少空间，编译器会给出一个带有此有用建议的错误：

help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
  |
2 |     Cons(i32, Box<List>),
  |               ++++    +

在这个建议中，间接性意味着我们不应该直接存储值，而应该通过存储指向该值的指针来间接地存储值。

因为 Box<T> 是一个指针，Rust 始终知道 Box<T> 需要多少空间：指针的大小不会根据它指向的数据量而变化。这意味着我们可以将 Box<T> 放在 Cons 变体中，而不是直接放另一个 List 值。Box<T> 将指向堆上的下一个 List 值，而不是放在 Cons 变体内部。从概念上讲，我们仍然有一个列表，通过列表包含其他列表来创建，但这种实现现在更像是将项目并排放置而不是嵌套在一起。

我们可以更改列表 15-2 中的 List 枚举定义和列表 15-3 中的 List 使用，使其变为列表 15-5 中的代码，这样可以编译。

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}

Cons 变体需要一个 i32 的大小加上存储盒子指针数据的空间。Nil 变体不存储任何值，因此它在栈上占用的空间比 Cons 变体少。我们现在知道，任何 List 值都将占用一个 i32 的大小加上一个盒子指针数据的大小。通过使用盒子，我们打破了无限递归链，因此编译器可以计算出存储 List 值所需的空间。图 15-2 显示了现在的 Cons 变体的样子。

图15-2: 一个不是无限大小的List 因为Cons持有一个Box

Boxes 只提供间接性和堆分配；它们没有其他特殊功能，比如我们将在其他智能指针类型中看到的那些。它们也没有这些特殊功能带来的性能开销，因此在只需要间接性的情况下（如 cons 列表），它们可以非常有用。我们将在第 18 章中探讨更多使用 Boxes 的场景。

Box<T> 类型是一个智能指针，因为它实现了 Deref 特性，这使得 Box<T> 值可以像引用一样被处理。当 Box<T> 值超出作用域时，由于实现了 Drop 特性，盒子指向的堆数据也会被清理。这两个特性对于本章后续讨论的其他智能指针类型所提供的功能将更加重要。让我们更详细地探讨这两个特性。