Box<T> 堆分配 ​

什么是 Box<T> ​

Box<T> 是 Rust 标准库中最简单的智能指针,它的作用就是把一个值从栈上搬到堆上。栈上只保留一个指向堆内存的指针,而实际数据存放在堆里。当 Box<T> 离开作用域时,它会自动释放堆上的数据,不需要手动管理内存。

在 Rust 中,绝大部分值默认分配在栈上,栈分配速度快、效率高。但有些场景栈分配做不到或者不合适,这时候就需要 Box<T> 来做堆分配。你可以把 Box<T> 想象成一个"所有权包装盒":它拥有盒子里那个值的所有权,盒子销毁时里面的值也跟着销毁。

Box<T> 的内部结构 ​

Box<T> 在内存中的表示其实很简单。在 64 位系统上,一个 Box<T> 在栈上只占 8 个字节(一个指针的大小),不管 T 有多大。

rust
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 ​

rust
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 存放大数据 ​

当数据量很大时,直接放在栈上可能导致栈溢出。把大数据放到堆上就安全了。

rust
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 后传递只需要复制一个指针。

rust
// 一个比较大的结构体
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 引入间接层(一个固定大小的指针),就解决了这个问题。

链表 ​

rust
// 定义一个单链表
// 如果不用 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");
        }
    }
}

二叉树 ​

rust
// 二叉树节点
// 每个节点有一个值,以及可选的左子树和右子树
// 用 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 编译器会在需要的时候自动帮你解引用。

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。

rust
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 生命周期的引用。这个值永远不会被释放(除非你手动处理),所以要谨慎使用。

rust
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 的几个核心用法串在一起:

rust
// 用 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 是最简单的一个:没有引用计数、没有内部可变性、没有线程安全的额外开销,就是纯粹的"堆分配 + 所有权管理"。