Rust 智能指標 — `Box<T>`（堆積配置）

簡介

在 Rust 中，所有值預設都放在堆疊（stack）上，這讓編譯器能在編譯期即確定每個變數的大小與生命週期，進而保證記憶體安全。然而，許多情況下我們需要在**堆（heap）**上配置資料：

資料大小在編譯期無法確定（例如遞迴資料結構）。
想要將大型物件搬移而不產生大量的複製成本。
需要將所有權轉移給另一個執行緒或 API，而該所有權必須是 單一且唯一 的。

Box<T> 正是為了這些需求而設計的 智能指標（smart pointer）。它在堆上配置 T，同時在棧上保存一個指向堆記憶體的指標，並在 Box 被丟棄時自動釋放堆上的資源。透過 Box<T>，我們可以在安全且可預測的前提下，靈活使用堆積配置。

核心概念

1. `Box<T>` 的基本用法

Box::new 會在堆上配置一個值，並回傳擁有所有權的 Box<T>。

fn main() {
    // 在堆上配置一個 i32，值為 42
    let b = Box::new(42);
    // 透過解引用取得內部值
    println!("盒子裡的值是 {}", *b);
} // b 超出作用域，堆上的 42 被自動釋放

b 本身是一個 指向堆記憶體的指標，但它的大小仍然是棧上固定的 usize（指標大小）。
當 b 被 drop 時，Box 會呼叫 dealloc 釋放堆上的記憶體，不需要手動 free。

2. 為什麼要使用 `Box<T>` 而不是 `Vec<T>` 或 `Rc<T>`？

需求	`Box<T>`	`Vec<T>`	`Rc<T>`
單一所有權、固定大小	✅	❌（需要 `len`）	❌（多所有權）
需要在堆上配置任意型別	✅	❌（只能是同質集合）	✅（多所有權）
需要共享只讀存取	❌	✅（`Arc`）	✅（`Rc`）

簡言之，當你只需要「把一個值搬到堆上」且仍保持唯一所有權 時，Box<T> 是最直接、最輕量的選擇。

3. `Box<T>` 與遞迴資料結構

Rust 的編譯器在編譯時必須知道每個型別的大小。遞迴結構（如鏈表、樹）如果直接包含自身，大小會無限遞增，編譯失敗。使用 Box<T> 可以斷開遞迴，因為指標的大小是已知的。

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

fn main() {
    // 建立一個長度為 3 的鏈表
    let list = List::Cons(
        1,
        Box::new(List::Cons(
            2,
            Box::new(List::Cons(3, Box::new(List::Nil))),
        )),
    );

    // 只要有 `&list` 就能遞迴遍歷
    print_list(&list);
}

fn print_list(l: &List) {
    match l {
        List::Cons(v, next) => {
            println!("{}", v);
            print_list(next);
        }
        List::Nil => {}
    }
}

Box<List> 把遞迴層級限制在指標大小，使編譯器能正確計算 List 的大小。
所有權仍然是唯一的：每個 Cons 節點擁有它的 Box，沒有共享。

4. `Box<T>` 與 trait object（動態分發）

Box 也常用於 trait object，讓我們在執行時決定要呼叫哪個實作。

trait Shape {
    fn area(&self) -> f64;
}

struct Circle { radius: f64 }
impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
}

struct Rectangle { w: f64, h: f64 }
impl Shape for Rectangle {
    fn area(&self) -> f64 { self.w * self.h }
}

fn main() {
    // 用 Box<dyn Shape> 把不同型別的 Shape 放在同一容器
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 2.0 }),
        Box::new(Rectangle { w: 3.0, h: 4.0 }),
    ];

    for s in shapes.iter() {
        println!("面積 = {}", s.area());
    }
}

Box<dyn Shape> 把 trait object 放到堆上，因為大小在編譯期未知。
透過 Box，我們可以在同一容器中儲存不同的實作，且仍保持 單一所有權。

5. `Box<T>` 的解構與 `*`、`as_ref`、`as_mut`

fn main() {
    let mut b = Box::new(String::from("Hello"));
    
    // 取得不可變參考
    let r: &String = b.as_ref();
    println!("{}", r);
    
    // 取得可變參考
    let m: &mut String = b.as_mut();
    m.push_str(", world!");
    println!("{}", m);
    
    // 完全取得所有權（移動）
    let s: String = *b; // b 被搬走，之後不可再使用
    println!("{}", s);
}

as_ref / as_mut 不會消耗 Box，僅返回參考。
*b 會把 Box 內的值搬走，等同於 *b 的 std::ops::Deref 產生的所有權轉移。

常見陷阱與最佳實踐

陷阱	說明	建議的做法
忘記 `Box` 會自動釋放	有時會手動呼叫 `std::mem::drop`，導致雙重釋放。	讓所有權自然離開作用域，除非真的需要提前釋放。
過度使用 `Box`	把所有資料都 `Box` 起來會增加間接存取成本（快取未命中）。	僅在需要堆配置或遞迴時使用，其餘情況保持棧上資料。
`Box<T>` 與 `Rc<T>`/`Arc<T>` 混用	把 `Box<T>` 直接傳給多所有權容器會失去唯一所有權的保證。	若需要共享，直接使用 `Rc<T>`/`Arc<T>`，不必先 `Box`。
在 `no_std` 環境下使用 `Box`	`Box` 依賴全域分配器，`no_std` 預設沒有。	在 `no_std` 時，使用 `alloc::boxed::Box` 並提供自訂分配器。
遞迴結構忘記 `Box`	直接寫 `enum Node { Next(Node) }` 會編譯失敗。	永遠在遞迴位置使用 `Box`，或改用 `Option<Box<Node>>`。

最佳實踐

保持 Box 的唯一所有權：除非你有意把它轉成 Rc/Arc，否則不要克隆或多重引用。
使用 Box::new 直接建構：避免手動呼叫 std::alloc，保持安全抽象。
在需要 trait object 時才使用 Box<dyn Trait>：如果可以用泛型（impl Trait）解決，盡量避免動態分發的開銷。
釋放前檢查是否仍在使用：使用 IDE 或 cargo clippy 捕捉可能的「使用已移動值」錯誤。
在性能關鍵路徑測試：使用 cargo bench 或 criterion 評估 Box 的間接存取成本是否影響需求。

實際應用場景

1. 建構抽象語法樹（AST）

編譯器常用 Box 來表示節點的子樹，因為每個節點的子樹大小在編譯期未知。

enum Expr {
    Literal(i64),
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
}

enum BinOp { Add, Sub, Mul, Div }

fn eval(e: &Expr) -> i64 {
    match e {
        Expr::Literal(v) => *v,
        Expr::Binary { left, op, right } => {
            let l = eval(left);
            let r = eval(right);
            match op {
                BinOp::Add => l + r,
                BinOp::Sub => l - r,
                BinOp::Mul => l * r,
                BinOp::Div => l / r,
            }
        }
    }
}

每個 Binary 節點只持有兩個 Box<Expr>，保持 固定大小，同時允許無限深度的表達式。

2. 動態載入插件（Plugin）

在需要 載入未知型別的插件 時，常用 Box<dyn Plugin>：

trait Plugin {
    fn name(&self) -> &str;
    fn run(&self);
}

// 假設我們在執行時從動態庫取得實作
fn load_plugin() -> Box<dyn Plugin> {
    // 省略實作細節，返回 Box<dyn Plugin>
    unimplemented!()
}

fn main() {
    let plugin = load_plugin();
    println!("載入插件：{}", plugin.name());
    plugin.run(); // 動態分發
}

Box 讓插件的實例 在堆上，且所有權交給主程式，安全且易於管理。

3. 大型資料結構的延遲初始化

有時候我們只在特定條件下才需要分配大塊記憶體，使用 Option<Box<T>> 可以延遲配置。

struct Cache {
    data: Option<Box<[u8; 1024 * 1024]>>, // 1 MiB 緩衝區
}

impl Cache {
    fn new() -> Self { Self { data: None } }

    fn init(&mut self) {
        if self.data.is_none() {
            self.data = Some(Box::new([0u8; 1024 * 1024]));
        }
    }
}

只有在 init 被呼叫時才分配 1 MiB，節省啟動時的記憶體開銷。

總結

Box<T> 是 唯一所有權的堆積智能指標，在需要將值搬到堆上、建立遞迴資料結構、或使用 trait object 時不可或缺。
它的 自動釋放機制 讓開發者免除手動管理記憶體的負擔，同時保持 Rust 的安全保證。
使用 Box 時要注意 避免過度間接、保持 唯一所有權，並在適當的情境（遞迴、動態分發、延遲初始化）下使用，才能發揮最佳效能與可讀性。

透過本文的概念與範例，你應該已能在自己的程式碼中自信地運用 Box<T>，無論是構建抽象語法樹、實作插件系統，或是管理大型緩衝區，都能以 安全、清晰且效能友好 的方式完成。祝你在 Rust 的旅程中玩得開心，寫出更好、更安全的程式！

Rust 智能指標 — Box<T>（堆積配置）

簡介