Rust 的 Vec<T> 是最常用的动态数组类型之一，它在性能、内存安全与底层控制之间达到了极佳平衡。很多人用过 Vec，但鲜有人真正理解它在内存中的布局，以及为何扩容时不会“凭空消失”旧数据。本文将从底层剖析 Vec 的设计，并通过代码验证其扩容行为。

---

一、Vec 的核心结构

Rust 标准库中，Vec<T> 本质上是一个拥有堆上数据所有权的结构体，其底层由三部分组成：

1. 指针（ptr）：指向堆中首个元素；
2. 长度（len）：当前已使用的元素个数；
3. 容量（cap）：分配的最大元素数量。

伪代码如下：

struct Vec<T> {
    ptr: *mut T,
    len: usize,
    cap: usize,
}

可以看到，Vec 并不是一个“连续存储的数据块”，而是一个小型的三元结构，真正的数据放在堆上。

---

二、Vec 的内存布局观察

我们可以通过 std::mem 模块来验证其布局：

use std::mem;

fn main() {
    let v = vec![1, 2, 3];
    println!("Vec size: {}", mem::size_of_val(&v));
    println!("Vec len: {}, cap: {}", v.len(), v.capacity());
}

输出大致如下（在 64 位系统上）：

Vec size: 24
Vec len: 3, cap: 3

说明一个 Vec 变量本身仅占用 24 字节（3 个 usize 大小），数据部分另存在堆上。

💡 思考：这意味着将 Vec 作为函数参数传递时，复制的只是指针与元数据，而非整个数据块，从而保持高效。

---

三、扩容策略的秘密

当 Vec 容量不够时，Rust 会自动触发扩容。其核心策略类似于“几何增长”，通常每次扩容为原容量的 2 倍。这样既减少频繁分配的开销，又避免过度浪费内存。

下面通过实验来观察扩容行为：

fn main() {
    let mut v = Vec::new();
    for i in 0..10 {
        v.push(i);
        println!("len: {}, cap: {}", v.len(), v.capacity());
    }
}

输出示例：

len: 1, cap: 1
len: 2, cap: 2
len: 3, cap: 4
len: 5, cap: 8
len: 9, cap: 16

可以看到，cap 的变化呈指数增长。这种策略的好处是均摊摊销成本：虽然扩容时会发生一次性复制，但在平均意义上，每次 push 的代价仍为 O(1)。

---

四、扩容的实现原理

当 Vec 扩容时，会：

1. 向分配器请求更大的内存；
2. 将旧数据复制到新区域；
3. 释放旧内存。

Rust 的内存分配器（默认基于 jemalloc 或系统分配器）负责这一过程。值得注意的是，扩容会导致指针失效：

let mut v = vec![1, 2, 3];
let p = &v[0] as *const i32;
v.push(4); // 若发生扩容，p 将不再有效

因此，在可能扩容的情况下，持有旧引用是不安全的，也是 Vec 不允许安全代码中同时存在可变借用与不可变借用的原因。

---

五、手动控制容量与性能优化

Rust 提供了一些方法让我们手动控制扩容行为：

• Vec::with_capacity(n)：预先分配空间；
• Vec::reserve(n)：保证再插入 n 个元素时不会重新分配；
• Vec::shrink_to_fit()：收缩多余容量。

示例：

let mut data = Vec::with_capacity(1000);
for i in 0..1000 {
    data.push(i);
}
println!("Final capacity: {}", data.capacity());

这样预分配空间可以避免多次扩容，特别是在大数据批量加载、数值计算或高频 I/O 场景中能显著提升性能。

---

六、总结与思考

Vec 的设计体现了 Rust 一贯的哲学：零成本抽象 + 明确的所有权模型。
其三元结构 (ptr, len, cap) 让我们能够在安全层面高效地操作堆内存；而几何扩容策略在性能与内存利用率之间找到了平衡。

在性能敏感的应用中，我们应当：

• 预估数据量，合理预分配；
• 避免在循环中频繁扩容；
• 谨慎使用指针或引用，避免扩容后悬垂引用。

深入理解 Vec 的内存布局，不仅有助于写出高性能的 Rust 程序，也能帮助我们更好地理解系统层面的内存管理理念。