栈内存与堆内存
两种内存区域
程序运行时使用两种主要的内存区域:栈(Stack)和堆(Heap)。理解它们的区别是理解 Rust 所有权系统的基础——所有权规则的很多设计都源于栈和堆的不同特性。
栈内存
栈是一种后进先出(LIFO)的数据结构。函数调用时,参数和局部变量被压入栈;函数返回时,这些数据被弹出。栈上的内存分配和释放非常快,因为只需要移动栈指针。
栈的限制:存储的数据必须在编译期就知道大小,而且大小是固定的。
堆内存
堆是一片更大、更灵活的内存区域。程序可以在运行时从堆上申请任意大小的内存。堆分配比栈慢,因为操作系统需要找到一块足够大的空闲空间,做好记录,然后返回一个指针。
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 是理解栈堆关系的经典例子。
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());
}所有权与堆内存
所有权系统主要解决的是堆内存的管理问题。栈上的数据跟随函数自动分配释放,不需要特殊管理。
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 的内存布局
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());
}栈溢出与堆溢出
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());
}基本示例
展示不同类型在栈和堆上的分配:
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 离开作用域时,堆上的数据自动释放。
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 等类型把元数据放在栈上、实际数据放在堆上。所有权系统的核心任务就是管理堆上的资源——通过编译期的所有权规则,确保每块堆内存都有且只有一个所有者,在所有者离开作用域时自动释放,既安全又高效。