栈内存与堆内存 ​

两种内存区域 ​

程序运行时使用两种主要的内存区域:栈(Stack)和堆(Heap)。理解它们的区别是理解 Rust 所有权系统的基础——所有权规则的很多设计都源于栈和堆的不同特性。

栈内存 ​

栈是一种后进先出(LIFO)的数据结构。函数调用时,参数和局部变量被压入栈;函数返回时,这些数据被弹出。栈上的内存分配和释放非常快,因为只需要移动栈指针。

栈的限制:存储的数据必须在编译期就知道大小,而且大小是固定的。

堆内存 ​

堆是一片更大、更灵活的内存区域。程序可以在运行时从堆上申请任意大小的内存。堆分配比栈慢,因为操作系统需要找到一块足够大的空闲空间,做好记录,然后返回一个指针。

rust
fn main() {
    // 栈上的数据:大小在编译期已知
    let x: i32 = 42;           // 4 字节,在栈上
    let y: f64 = 3.14;         // 8 字节,在栈上
    let flag: bool = true;     // 1 字节,在栈上
    let arr: [i32; 5] = [1, 2, 3, 4, 5];  // 20 字节,在栈上

    // 堆上的数据:大小在运行时确定或可变
    let s = String::from("hello");    // 字符串数据在堆上,指针/长度/容量在栈上
    let v = vec![1, 2, 3, 4, 5];     // Vec 数据在堆上,元数据在栈上
    let b = Box::new(100);            // 100 被放到堆上,Box 指针在栈上

    println!("栈上:x={}, y={}, flag={}", x, y, flag);
    println!("堆上:s={}, v={:?}, b={}", s, v, b);
}

栈与堆的对比 ​

特性栈 (Stack)堆 (Heap)
分配速度非常快(移动栈指针)较慢(需要查找空闲空间)
释放速度非常快(自动弹出)需要显式管理(Rust 用 Drop)
大小要求编译期已知,固定大小运行时确定,可动态增长
数据生命周期跟随函数调用跟随所有权
访问速度更快(缓存友好)较慢(通过指针间接访问)
典型用途局部变量、函数参数动态数据、大型数据
Rust 中的类型i32、f64、bool、[T; N]String、Vec<T>、Box<T>

String 的内存布局 ​

String 是理解栈堆关系的经典例子。

rust
fn main() {
    let s = String::from("hello");

    // String 在内存中的结构:
    // 栈上(String 结构体本身):
    //   ┌──────────┐
    //   │ ptr  ────────→ 堆上的数据
    //   │ len: 5    │     ┌───┬───┬───┬───┬───┐
    //   │ cap: 5    │     │ h │ e │ l │ l │ o │
    //   └──────────┘     └───┴───┴───┴───┴───┘
    //
    // ptr:指向堆上数据的指针
    // len:当前字符串长度(5 字节)
    // cap:已分配的容量(至少 5 字节)

    println!("内容:{}", s);
    println!("长度:{}", s.len());
    println!("容量:{}", s.capacity());
    println!("指针:{:p}", s.as_ptr());
}

所有权与堆内存 ​

所有权系统主要解决的是堆内存的管理问题。栈上的数据跟随函数自动分配释放,不需要特殊管理。

rust
fn main() {
    // 栈上的数据:Copy 语义
    let a = 10;
    let b = a;  // 复制了一份,a 和 b 是独立的两份数据
    println!("a={}, b={}", a, b);  // 两个都有效

    // 堆上的数据:Move 语义
    let s1 = String::from("hello");
    let s2 = s1;  // 所有权转移,s1 失效
    // 如果 s1 和 s2 都有效,两者都会尝试释放同一块堆内存 → 双重释放
    // Rust 通过让 s1 失效来避免这个问题
    println!("s2={}", s2);
    // println!("s1={}", s1);  // 编译错误

    // 如果确实需要两份独立的数据,用 clone
    let s3 = String::from("world");
    let s4 = s3.clone();  // 深拷贝:堆上的数据也复制了一份
    println!("s3={}, s4={}", s3, s4);  // 两个都有效,各自拥有独立的堆数据
}

Vec 的内存布局 ​

rust
fn main() {
    let mut v = Vec::with_capacity(4);

    // Vec 在内存中的结构:
    // 栈上:
    //   ┌──────────┐
    //   │ ptr  ────────→ 堆上的连续内存
    //   │ len: 0    │
    //   │ cap: 4    │
    //   └──────────┘

    v.push(10);
    v.push(20);
    v.push(30);

    // 现在 len=3, cap=4
    // 堆上:[10, 20, 30, _](_ 表示已分配但未使用)

    println!("内容:{:?}", v);
    println!("长度:{}", v.len());
    println!("容量:{}", v.capacity());

    // 当容量不够时,Vec 会重新分配更大的堆内存
    v.push(40);
    v.push(50);  // 超过容量,触发重新分配
    println!("扩容后容量:{}", v.capacity());
}

栈溢出与堆溢出 ​

rust
fn main() {
    // 栈空间有限(通常几 MB),放太大的数据会栈溢出
    // let huge_array = [0u8; 10_000_000];  // 10MB 数组在栈上,可能溢出

    // 大数据应该放在堆上
    let huge_vec = vec![0u8; 10_000_000];  // 10MB 在堆上,没问题
    println!("堆上 Vec 大小:{} 字节", huge_vec.len());

    // 用 Box 把数据放到堆上
    let boxed_array = Box::new([0u8; 1_000_000]);  // 1MB 在堆上
    println!("Box 中数组大小:{} 字节", boxed_array.len());
}

基本示例 ​

展示不同类型在栈和堆上的分配:

rust
use std::mem;

fn show_size<T>(name: &str) {
    // mem::size_of::<T>() 返回类型在栈上占用的字节数
    println!("{:<20} 栈上大小: {} 字节", name, mem::size_of::<T>());
}

fn main() {
    println!("=== 各类型的栈上大小 ===");
    println!();

    // 纯栈类型
    show_size::<i8>("i8");
    show_size::<i32>("i32");
    show_size::<i64>("i64");
    show_size::<f64>("f64");
    show_size::<bool>("bool");
    show_size::<char>("char");
    show_size::<[i32; 10]>("[i32; 10]");
    show_size::<(i32, f64, bool)>("(i32, f64, bool)");

    println!();

    // 涉及堆的类型(栈上只有元数据)
    show_size::<String>("String");
    show_size::<Vec<i32>>("Vec<i32>");
    show_size::<Box<i32>>("Box<i32>");
    show_size::<&str>("&str");
    show_size::<&[i32]>("&[i32]");

    println!();

    // 实际数据示例
    let stack_data: [i32; 4] = [1, 2, 3, 4];
    let heap_data: Vec<i32> = vec![1, 2, 3, 4];

    println!("栈数组:{:?}(全部 {} 字节在栈上)",
        stack_data, mem::size_of_val(&stack_data));
    println!("堆 Vec:{:?}({} 字节在栈上 + {} 字节在堆上)",
        heap_data, mem::size_of_val(&heap_data),
        heap_data.len() * mem::size_of::<i32>());
}

常见问题 ​

问题一:怎么判断一个类型的数据在栈上还是堆上?

简单规则:编译期大小固定且实现了 Copy 的类型(基本类型、固定大小数组、纯 Copy 元组)在栈上。String、Vec、Box、HashMap 等拥有堆分配数据的类型,它们的元数据在栈上,实际数据在堆上。

问题二:栈上的数据为什么不需要所有权管理?

栈上的数据跟随函数调用自动分配和释放,复制成本低(Copy 语义),不存在"谁来释放"的问题。所有权系统主要管理堆上的资源。

问题三:为什么堆比栈慢?

栈只需移动栈指针,O(1) 操作。堆需要查找合适大小的空闲块、记录分配信息、返回指针,而且堆上数据通过指针间接访问,对 CPU 缓存不友好。

问题四:Box 是什么?

Box<T> 是最简单的堆分配类型——它把类型 T 的数据放到堆上,栈上只存一个指针。当 Box 离开作用域时,堆上的数据自动释放。

rust
fn main() {
    // 把一个 i32 放到堆上
    let boxed = Box::new(42);
    println!("Box 中的值:{}", boxed);

    // 把一个大数组放到堆上,避免栈溢出
    let big = Box::new([0u8; 100_000]);
    println!("大数组长度:{}", big.len());
}

适用场景 ​

  • 栈:局部变量、函数参数、小型固定大小的数据
  • 堆:动态大小的数据(字符串、动态数组)、大型数据、需要跨作用域传递所有权的数据
  • Box:需要在堆上放固定大小类型、递归数据结构

注意事项 ​

  • 栈空间有限(通常 1-8 MB),不要在栈上放太大的数据
  • 堆分配比栈慢,但空间大得多
  • String、Vec、Box 等类型的栈部分存储指针和元数据,实际数据在堆上
  • mem::size_of::<T>() 返回的是类型在栈上的大小,不包括堆上的数据
  • Rust 的所有权系统负责堆内存的自动释放,不需要手动管理
  • Copy 类型在栈上直接复制,非 Copy 类型通过所有权转移来管理堆资源

总结 ​

栈和堆是程序的两种内存区域。栈速度快、自动管理,但只能存储编译期大小已知的固定数据。堆空间大、灵活,可以存储动态大小的数据,但分配和访问速度较慢。Rust 的 String、Vec、Box 等类型把元数据放在栈上、实际数据放在堆上。所有权系统的核心任务就是管理堆上的资源——通过编译期的所有权规则,确保每块堆内存都有且只有一个所有者,在所有者离开作用域时自动释放,既安全又高效。