Box<T> 堆分配
什么是 Box<T>
Box<T> 是 Rust 标准库中最简单的智能指针,它的作用就是把一个值从栈上搬到堆上。栈上只保留一个指向堆内存的指针,而实际数据存放在堆里。当 Box<T> 离开作用域时,它会自动释放堆上的数据,不需要手动管理内存。
在 Rust 中,绝大部分值默认分配在栈上,栈分配速度快、效率高。但有些场景栈分配做不到或者不合适,这时候就需要 Box<T> 来做堆分配。你可以把 Box<T> 想象成一个"所有权包装盒":它拥有盒子里那个值的所有权,盒子销毁时里面的值也跟着销毁。
Box<T> 的内部结构
Box<T> 在内存中的表示其实很简单。在 64 位系统上,一个 Box<T> 在栈上只占 8 个字节(一个指针的大小),不管 T 有多大。
use std::mem::size_of;
fn main() {
// Box<T> 在栈上的大小始终是一个指针的大小(8 字节,64 位系统)
println!("Box<u8> 栈上大小: {} 字节", size_of::<Box<u8>>());
println!("Box<[u8; 1000]> 栈上大小: {} 字节", size_of::<Box<[u8; 1000]>>());
println!("Box<String> 栈上大小: {} 字节", size_of::<Box<String>>());
// 对比:直接在栈上存放的大小
println!("[u8; 1000] 栈上大小: {} 字节", size_of::<[u8; 1000]>());
println!("String 栈上大小: {} 字节", size_of::<String>());
}栈上只存一个指针,真正的数据在堆上。这就是 Box<T> 能做到"大数据小搬运"的原因——传递一个 Box<T> 只需要复制 8 个字节的指针,而不是复制整个数据。
基本用法
创建和使用 Box
fn main() {
// 用 Box::new 把值放到堆上
let boxed_num = Box::new(42);
// Box 实现了 Deref trait,可以像普通引用一样使用
// 不需要写 *boxed_num 也能打印
println!("堆上的数字: {}", boxed_num);
// 如果需要拿到里面的值,用 * 解引用
let value = *boxed_num;
println!("取出的值: {}", value);
}用 Box 存放大数据
当数据量很大时,直接放在栈上可能导致栈溢出。把大数据放到堆上就安全了。
fn main() {
// 这个数组有 100 万个元素,直接放栈上可能导致栈溢出
// let large_array: [u8; 1_000_000] = [0; 1_000_000]; // 危险!
// 用 Box 放到堆上就安全了
let large_array: Box<[u8; 1_000_000]> = Box::new([0; 1_000_000]);
println!("大数组的第一个元素: {}", large_array[0]);
println!("大数组的长度: {}", large_array.len());
// large_array 离开作用域时,堆上的 100 万字节自动释放
}用 Box 高效传递大结构体
传递大结构体时,如果不用引用,正常情况下会发生移动(Move),虽然编译器会优化,但把大结构体装进 Box 后传递只需要复制一个指针。
// 一个比较大的结构体
struct ImageBuffer {
pixels: [u8; 4096], // 4KB 的像素数据
width: u32,
height: u32,
format: String,
}
// 参数是 Box<ImageBuffer>,传递时只移动一个指针
fn process_image(image: Box<ImageBuffer>) {
println!(
"处理图像: {}x{}, 格式: {}",
image.width, image.height, image.format
);
// image 在这里被使用后,函数结束时自动释放堆内存
}
fn main() {
// 创建 ImageBuffer 并放到堆上
let image = Box::new(ImageBuffer {
pixels: [255; 4096],
width: 64,
height: 64,
format: String::from("RGBA"),
});
// 传递 Box,只移动了 8 字节的指针
process_image(image);
// image 的所有权已经移走了,这里不能再用
// println!("{}", image.width); // 编译错误
}递归类型:Box 的核心使用场景
这是 Box<T> 最经典的用途。Rust 在编译期需要知道每个类型占多少空间,但递归类型的大小是无限嵌套的,编译器算不出来。通过 Box 引入间接层(一个固定大小的指针),就解决了这个问题。
链表
// 定义一个单链表
// 如果不用 Box,List 的大小会是无限的:
// List = i32 + List = i32 + i32 + List = ...
// 用了 Box 后,List = i32 + Box<List> = i32 + 指针大小,编译器可以计算出来
enum List {
// Cons 节点包含一个值和指向下一个节点的 Box 指针
Cons(i32, Box<List>),
// Nil 表示链表结束
Nil,
}
use List::{Cons, Nil};
fn main() {
// 创建链表: 1 -> 2 -> 3 -> Nil
let list = Cons(
1,
Box::new(Cons(
2,
Box::new(Cons(
3,
Box::new(Nil),
)),
)),
);
// 遍历链表
print_list(&list);
}
// 递归遍历链表并打印每个元素
fn print_list(list: &List) {
match list {
Cons(value, next) => {
print!("{} -> ", value);
// 递归处理下一个节点
print_list(next);
}
Nil => {
println!("Nil");
}
}
}二叉树
// 二叉树节点
// 每个节点有一个值,以及可选的左子树和右子树
// 用 Option<Box<TreeNode>> 表示子节点可能存在也可能不存在
struct TreeNode {
value: i32,
left: Option<Box<TreeNode>>,
right: Option<Box<TreeNode>>,
}
impl TreeNode {
// 创建叶子节点(没有子节点)
fn leaf(value: i32) -> Self {
TreeNode {
value,
left: None,
right: None,
}
}
// 创建带子节点的节点
fn with_children(value: i32, left: TreeNode, right: TreeNode) -> Self {
TreeNode {
value,
left: Some(Box::new(left)),
right: Some(Box::new(right)),
}
}
// 计算树的深度
fn depth(&self) -> usize {
let left_depth = match &self.left {
Some(node) => node.depth(),
None => 0,
};
let right_depth = match &self.right {
Some(node) => node.depth(),
None => 0,
};
// 当前节点深度 = 1 + 左右子树中较大的深度
1 + left_depth.max(right_depth)
}
}
fn main() {
// 构建一棵二叉树:
// 1
// / \
// 2 3
// / \
// 4 5
let tree = TreeNode::with_children(
1,
TreeNode::with_children(
2,
TreeNode::leaf(4),
TreeNode::leaf(5),
),
TreeNode::leaf(3),
);
println!("树的深度: {}", tree.depth()); // 输出: 树的深度: 3
}Box 的自动解引用(Deref)
Box<T> 实现了 Deref trait,这意味着你可以把 Box<T> 当作 &T 来用。Rust 编译器会在需要的时候自动帮你解引用。
fn main() {
let boxed_string = Box::new(String::from("hello, rust"));
// Box<String> 自动解引用为 &String,再进一步解引用为 &str
// 所以可以直接调用 &str 的方法
println!("长度: {}", boxed_string.len());
println!("大写: {}", boxed_string.to_uppercase());
// 也可以传给接受 &str 的函数
print_str(&boxed_string);
}
// 这个函数接受 &str 参数
fn print_str(s: &str) {
println!("内容: {}", s);
}Deref 强制转换链条:Box<String> -> &String -> &str。这个过程是编译器自动完成的,不需要手动写转换代码。
Box::into_raw 和 Box::from_raw
在与 C 语言互操作(FFI)或者需要手动管理内存的场景下,可以用 into_raw 把 Box 转成裸指针,用 from_raw 把裸指针转回 Box。
fn main() {
// 创建一个 Box
let boxed = Box::new(String::from("FFI 数据"));
// 把 Box 转换为裸指针,此时 Box 不再管理这块内存
// 内存不会被自动释放,你需要手动负责
let raw_ptr: *mut String = Box::into_raw(boxed);
// 此时 boxed 已经被消费了,不能再使用
// println!("{}", boxed); // 编译错误
unsafe {
// 通过裸指针读取数据
println!("裸指针指向的数据: {}", *raw_ptr);
// 用完后必须转回 Box 来释放内存
// 如果忘了这步,就会内存泄漏
let recovered = Box::from_raw(raw_ptr);
println!("恢复的数据: {}", recovered);
// recovered 离开作用域时,内存被正常释放
}
}Box::leak
Box::leak 可以把 Box 中的值"泄漏"出来,得到一个 'static 生命周期的引用。这个值永远不会被释放(除非你手动处理),所以要谨慎使用。
fn main() {
// 把 Box 泄漏为 'static 引用
let static_str: &'static str = Box::leak(Box::new(String::from("永久存在的字符串")));
// 这个引用的生命周期是 'static,可以在程序的任何地方使用
println!("{}", static_str);
// 注意:这块内存在程序结束前不会被释放
// 适合用于全局配置、单例等场景
}
// 一个实际的使用场景:运行时生成的全局配置
fn create_config() -> &'static str {
let config = format!("version=0.1.0");
// 把动态生成的字符串变成 'static 引用
Box::leak(config.into_boxed_str())
}基本示例
下面是一个综合示例,把 Box 的几个核心用法串在一起:
// 用 Box 实现一个简单的表达式求值器
// 这是递归类型的经典应用
// 表达式枚举:可以是数字、加法或乘法
enum Expr {
// 数字字面量
Num(f64),
// 加法:左操作数 + 右操作数
Add(Box<Expr>, Box<Expr>),
// 乘法:左操作数 * 右操作数
Mul(Box<Expr>, Box<Expr>),
}
impl Expr {
// 递归求值
fn eval(&self) -> f64 {
match self {
Expr::Num(n) => *n,
Expr::Add(left, right) => left.eval() + right.eval(),
Expr::Mul(left, right) => left.eval() * right.eval(),
}
}
// 递归打印表达式
fn display(&self) -> String {
match self {
Expr::Num(n) => format!("{}", n),
Expr::Add(left, right) => {
format!("({} + {})", left.display(), right.display())
}
Expr::Mul(left, right) => {
format!("({} * {})", left.display(), right.display())
}
}
}
}
// 辅助函数,简化创建过程
fn num(n: f64) -> Box<Expr> {
Box::new(Expr::Num(n))
}
fn add(left: Box<Expr>, right: Box<Expr>) -> Box<Expr> {
Box::new(Expr::Add(left, right))
}
fn mul(left: Box<Expr>, right: Box<Expr>) -> Box<Expr> {
Box::new(Expr::Mul(left, right))
}
fn main() {
// 构建表达式: (2 + 3) * (4 + 1)
let expr = mul(
add(num(2.0), num(3.0)),
add(num(4.0), num(1.0)),
);
println!("表达式: {}", expr.display());
println!("结果: {}", expr.eval());
// 输出:
// 表达式: ((2 + 3) * (4 + 1))
// 结果: 25
}常见问题
问题一:什么时候用 Box,什么时候直接放栈上?
大部分情况下不需要 Box,直接放栈上就行。只有在以下情况才需要考虑 Box:递归类型(编译器要求)、数据量特别大(防止栈溢出)、需要 trait 对象(Box<dyn Trait>)、需要确保数据在堆上有稳定的地址。如果只是一个普通的 i32 或小结构体,用 Box 反而浪费性能。
问题二:Box 和引用(&T)有什么区别?
| 特性 | Box<T> | &T |
|---|---|---|
| 所有权 | 拥有数据的所有权 | 只是借用,不拥有 |
| 生命周期 | 数据跟随 Box 存在 | 不能超过被引用值的生命周期 |
| 存储位置 | 数据在堆上 | 指向的数据可能在栈上或堆上 |
| 大小 | 固定一个指针大小 | 固定一个指针大小(胖指针除外) |
| Drop | 离开作用域时释放堆内存 | 不负责释放内存 |
问题三:Box 有没有运行时开销?
有,但很小。主要开销是堆分配和释放的时间。每次 Box::new 都需要向操作系统申请堆内存(通过全局分配器),每次 Box 被 drop 时也需要释放内存。对于频繁创建销毁的小对象,这个开销可能比较明显。栈分配基本上是零成本的(只需要移动栈指针),所以对于小数据优先用栈。
问题四:Box 能不能共享所有权?
不能。Box<T> 是独占所有权的,同一时刻只有一个 Box 拥有数据。如果你需要多个所有者共享同一份数据,应该用 Rc<T>(单线程)或 Arc<T>(多线程)。
适用场景
- 递归数据结构:链表、树、图等需要自引用的类型,编译器要求通过 Box 引入间接层
- 大数据搬运:把大数组、大结构体放到堆上,避免栈溢出,传递时只需移动指针
- Trait 对象:
Box<dyn Trait>是最常见的动态分派方式(详见 11.2 节) - FFI 互操作:通过
into_raw/from_raw与 C 代码交换堆内存指针 - 需要稳定内存地址:堆上的数据地址不会因为栈帧变化而改变,适合需要固定地址的场景
- 全局静态数据:通过
Box::leak创建'static生命周期的引用
注意事项
Box::new每次调用都会进行一次堆分配,在性能敏感的热循环中要注意这个开销Box<T>只能有一个所有者,如果需要共享所有权,请使用Rc<T>或Arc<T>- 使用
Box::from_raw时必须确保指针确实来自Box::into_raw,且只能from_raw一次,否则会导致双重释放 Box::leak会导致内存永久不释放(直到程序退出),不要在循环中滥用- 对于实现了
Copy的小类型(如i32、bool),用 Box 包装没有意义,反而增加了间接寻址的开销 Box<T>在 FFI 场景下与 C 的T*指针布局兼容,但不要把任意 C 指针转成 Box,只有通过全局分配器分配的指针才能安全转换- 在 Rust 1.94 中,
Box的分配行为仍然使用全局分配器(Global),自定义分配器 API(allocator_api)尚未稳定
总结
Box<T> 是 Rust 中最基础的智能指针,它解决的核心问题是"把数据从栈搬到堆上"。它的实现非常轻量——栈上就是一个裸指针,指向堆上的实际数据。当 Box 离开作用域时,堆内存自动释放,这是 Rust RAII 机制的体现。Box 最重要的使用场景是构建递归数据结构(链表、树等),因为 Rust 编译器需要在编译期知道类型的大小,而递归类型如果不加间接层就会是无限大小。除此之外,Box 也用于存放大数据以防止栈溢出、创建 trait 对象实现动态分派、以及 FFI 场景下与 C 代码交换指针。和其他智能指针相比,Box 是最简单的一个:没有引用计数、没有内部可变性、没有线程安全的额外开销,就是纯粹的"堆分配 + 所有权管理"。