1. 什么是内存分配与释放?
程序运行时,需要内存保存变量、对象、函数调用状态以及动态创建的数据结构。
内存分配(Memory Allocation):程序向操作系统、运行时或内存分配器申请可用内存。
内存释放(Memory Deallocation):程序或运行时将不再使用的内存归还给内存管理系统,使其能够被重新利用。
内存分配与释放贯穿程序的整个生命周期。
例如,C 语言:
#include <stdlib.h>
int main() {
int *ptr = malloc(sizeof(int));
if (ptr == NULL) {
return 1;
}
*ptr = 100;
free(ptr);
ptr = NULL;
return 0;
}
执行过程:
flowchart TB
A["程序申请内存"] --> B["分配器查找可用内存"]
B --> C["返回内存地址"]
C --> D["程序使用内存"]
D --> E["程序不再需要内存"]
E --> F["调用 free 释放内存"]
F --> G["内存归还分配器"]
G --> H["后续分配可以重新使用"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要区分三个概念:
- 内存申请:获取一块可以使用的内存区域。
- 对象创建:在内存中建立具有特定类型和生命周期的对象。
- 内存释放:结束相关存储的使用,并将其归还给管理系统。
在 C++ 中,内存分配与对象构造是两个不同的操作;在 Java、Python 等托管语言中,内存管理则主要由运行时负责。
2. 程序内存的主要区域
理解内存分配,首先需要了解程序运行时常见的内存区域。
典型进程的虚拟地址空间可以抽象为以下部分:
| 内存区域 | 主要用途 | 生命周期或管理方式 |
|---|---|---|
| 代码段(Text Segment) | 保存可执行指令 | 通常随进程生命周期存在 |
| 数据段(Data Segment) | 保存已初始化的全局变量和静态变量 | 通常随进程生命周期存在 |
| BSS 段 | 保存未显式初始化或零初始化的静态存储期变量 | 通常随进程生命周期存在 |
| 堆(Heap) | 支持动态内存分配 | 根据分配器和程序管理策略变化 |
| 栈(Stack) | 保存函数调用帧、局部变量等 | 通常随函数调用与返回变化 |
| 内存映射区域 | 映射文件、共享内存、匿名内存等 | 由映射与解除映射操作管理 |
这些区域是常见实现模型,并不意味着所有编程语言、操作系统和处理器都采用完全相同的布局。
2.1 栈内存分配
栈通常用于管理函数调用过程中的执行状态。
void calculate() {
int a = 10;
int b = 20;
int result = a + b;
}
在常见实现中,调用 calculate() 时会建立栈帧,用于保存局部数据、返回地址以及必要的寄存器状态。
函数返回后,对应栈帧不再有效,其占用空间可以被后续函数调用复用。
典型特征:
- 分配与释放通常由函数调用机制自动管理。
- 生命周期通常与作用域或函数调用相关。
- 分配和回收成本较低。
- 空间通常相对有限。
- 不适合无限增长或生命周期需要跨越当前调用的数据。
注意:不能简单认为所有局部变量都一定存储在栈上。编译器可能将变量放入寄存器、消除变量,或因逃逸分析等因素改变存储位置。
2.2 堆内存分配
堆用于支持生命周期不完全依赖当前函数调用的动态数据。
#include <stdlib.h>
void create_data() {
int *ptr = malloc(sizeof(int));
if (ptr == NULL) {
return;
}
*ptr = 100;
// 数据可以通过其他方式交给调用者
free(ptr);
}
堆内存的典型特征:
- 通过分配器动态申请。
- 申请大小可以在运行时决定。
- 生命周期可以跨越函数调用。
- 需要显式释放或由垃圾回收机制管理。
- 分配和回收涉及额外管理成本。
堆内存并不意味着一定由操作系统逐次分配。大多数运行时会通过内存分配器管理已经获取的内存块,以减少系统调用开销。
2.3 栈与堆的区别
| 对比维度 | 栈 | 堆 |
|---|---|---|
| 管理主体 | 通常由编译器和调用约定配合管理 | 通常由内存分配器或运行时管理 |
| 分配方式 | 常见为调整栈指针 | 通常需要查找或组织可用内存块 |
| 生命周期 | 通常与调用帧相关 | 可以由程序或运行时独立管理 |
| 分配速度 | 通常较快 | 通常有更多管理开销 |
| 空间大小 | 通常相对有限 | 通常更大,但受进程地址空间和系统资源限制 |
| 典型问题 | 栈溢出、栈上对象生命周期结束 | 内存泄漏、碎片化、重复释放 |
两者并不是简单的“栈快、堆慢”。实际性能取决于分配器、缓存局部性、对象大小、分配频率和内存访问模式。
3. 内存分配的实现机制
程序调用 malloc、new 或其他分配接口时,并不一定直接向操作系统申请一块新的物理内存。
中间通常存在内存分配器(Memory Allocator)。
3.1 内存分配器
内存分配器负责管理可用内存块,并为程序提供分配与释放接口。
常见职责包括:
- 管理空闲内存块。
- 根据申请大小选择合适的内存块。
- 维护内存块的元数据。
- 处理内存对齐要求。
- 合并相邻空闲块。
- 在需要时向操作系统申请或归还内存。
典型分配过程:
flowchart TB
A["程序请求指定大小的内存"] --> B["进入内存分配器"]
B --> C["查找空闲内存块"]
C --> D{"是否存在合适内存块"}
D -->|"是"| E["选择并切分内存块"]
D -->|"否"| F["向操作系统申请更多内存"]
F --> G["管理新增内存区域"]
G --> E
E --> H["更新分配器元数据"]
H --> I["返回可用地址"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
3.2 向操作系统申请内存
在 Linux 等操作系统中,用户态分配器可以通过系统调用或相关接口获取更大的内存区域。
常见机制包括:
brk/sbrk:调整进程数据段末端,属于传统堆管理机制。mmap:建立文件或匿名内存映射。munmap:解除内存映射。
现代分配器通常会根据申请大小、分配策略和运行环境选择不同路径。
例如:
- 小对象可能从已有内存池或空闲块中分配。
- 大对象可能直接通过内存映射获取独立区域。
- 释放小对象后,内存可能留在分配器中等待复用。
- 释放大块映射区域时,分配器可能解除映射并归还地址空间。
因此,调用 free() 后,进程占用的内存不一定立即下降。
3.3 虚拟内存与物理内存
现代操作系统通常使用虚拟内存机制。
程序使用的地址一般是虚拟地址,操作系统和处理器通过页表等机制将虚拟地址映射到物理内存。
需要区分:
- 虚拟地址空间:进程看到的地址空间。
- 物理内存:实际的 RAM。
- 内存映射:虚拟地址与物理资源之间的映射关系。
- 驻留内存:当前实际驻留在物理内存中的页面。
申请内存成功,并不总是意味着对应的物理页面已经全部分配并驻留。具体行为取决于操作系统的内存提交策略、页面访问情况和资源限制。
4. C 语言中的内存分配与释放
C 语言提供了一组标准动态内存管理函数,主要定义在 <stdlib.h> 中。
4.1 malloc:分配指定大小的内存
malloc 用于申请指定字节数的内存。
#include <stdlib.h>
int *ptr = malloc(sizeof(int));
if (ptr == NULL) {
// 分配失败
return 1;
}
*ptr = 100;
free(ptr);
函数原型:
void *malloc(size_t size);
特点:
- 参数表示申请的字节数。
- 成功时返回分配内存的起始地址。
- 失败时返回空指针。
- 返回内存的内容不保证初始化为零。
- 返回的内存具有适用于普通对象的基本对齐保证,具体保证由 C 标准规定。
如果需要分配数组,应注意计算总字节数时避免整数溢出。
4.2 calloc:分配并清零
calloc 用于分配指定数量、指定大小的元素,并将分配区域中的所有字节初始化为零。
#include <stdlib.h>
int *arr = calloc(5, sizeof(int));
if (arr == NULL) {
return 1;
}
free(arr);
函数原型:
void *calloc(size_t count, size_t size);
与 malloc 的主要区别:
| 函数 | 参数 | 初始化行为 |
|---|---|---|
malloc |
总字节数 | 不初始化 |
calloc |
元素数量、单个元素大小 | 将分配区域的字节置零 |
注意:将内存字节置零,不等同于对所有可能的 C 类型执行语言层面的默认初始化。对于常见整数类型,零字节表示整数零;但不能将这一点无条件推广到所有类型和对象表示。
4.3 realloc:调整内存大小
realloc 用于调整已经动态分配的内存块大小。
#include <stdlib.h>
int *arr = malloc(3 * sizeof(int));
if (arr == NULL) {
return 1;
}
int *new_arr = realloc(arr, 5 * sizeof(int));
if (new_arr == NULL) {
free(arr);
return 1;
}
arr = new_arr;
free(arr);
realloc 可能:
- 在原位置扩展内存块。
- 在其他位置分配新内存并复制原有内容。
- 释放旧内存块。
- 在失败时返回空指针,并保留原内存块。
因此,不能直接使用原指针接收 realloc 的返回值:
arr = realloc(arr, new_size); // 不推荐
如果分配失败,原指针可能丢失,导致原内存无法释放。
更安全的写法是使用临时指针。
int *temp = realloc(arr, new_size);
if (temp != NULL) {
arr = temp;
}
对于 realloc(ptr, 0),不同 C 标准版本及实现存在需要特别注意的差异。实际代码中建议显式处理零长度情况,而不是依赖其行为。
4.4 free:释放动态内存
free 用于释放由兼容的动态内存分配函数获得的内存块。
int *ptr = malloc(sizeof(int));
if (ptr != NULL) {
*ptr = 100;
free(ptr);
ptr = NULL;
}
需要遵守以下规则:
- 只能释放有效的动态分配指针。
- 不能释放普通局部变量地址。
- 不能重复释放同一块内存。
- 释放后不能继续访问该内存。
free(NULL)是合法操作,不执行释放。
4.5 C 语言动态内存管理完整示例
#include <stdio.h>
#include <stdlib.h>
int main(void) {
size_t count = 5;
int *arr = malloc(count * sizeof(*arr));
if (arr == NULL) {
return 1;
}
for (size_t i = 0; i < count; i++) {
arr[i] = (int)(i + 1) * 10;
}
int *temp = realloc(arr, 10 * sizeof(*arr));
if (temp == NULL) {
free(arr);
return 1;
}
arr = temp;
for (size_t i = count; i < 10; i++) {
arr[i] = 0;
}
for (size_t i = 0; i < 10; i++) {
printf("%d ", arr[i]);
}
free(arr);
arr = NULL;
return 0;
}
这个示例体现了动态内存管理的基本原则:
- 申请内存后检查结果。
- 使用内存前确保分配成功。
- 调整内存大小时使用临时指针。
- 释放内存后不再访问原地址。
5. C++ 中的内存分配与释放
C++ 在 C 的基础上提供了 new 和 delete,并进一步引入对象构造、析构、分配函数和智能指针等机制。
5.1 new:分配内存并构造对象
int* ptr = new int(100);
new 表达式通常包含两个阶段:
- 获取足够的存储空间。
- 在存储空间中构造对象。
对于类对象,构造函数会被调用。
#include <iostream>
class User {
public:
User() {
std::cout << "构造函数执行" << std::endl;
}
~User() {
std::cout << "析构函数执行" << std::endl;
}
};
int main() {
User* user = new User();
delete user;
return 0;
}
5.2 delete:析构对象并释放内存
delete 表达式通常包含:
- 调用对象的析构函数。
- 调用对应的释放函数归还存储空间。
int* ptr = new int(100);
delete ptr;
ptr = nullptr;
对于数组,必须使用 delete[]:
int* arr = new int[5];
delete[] arr;
arr = nullptr;
new[] 与 delete[] 必须正确配对。将数组形式的分配与普通 delete 混用,会导致未定义行为。
5.3 malloc/free 与 new/delete 的区别
| 对比维度 | malloc/free | new/delete |
|---|---|---|
| 所属语言机制 | C 标准库接口 | C++ 语言表达式 |
| 内存申请 | 申请指定字节数 | 根据类型申请存储空间 |
| 对象构造 | 不调用构造函数 | 调用构造函数 |
| 对象析构 | 不调用析构函数 | 调用析构函数 |
| 返回类型 | void* |
对应对象类型的指针 |
| 分配失败 | 通常返回空指针 | 默认抛出 std::bad_alloc |
| 数组支持 | 通过计算总字节数 | new[] / delete[] |
它们不能随意交叉配对:
int* ptr = new int(10);
free(ptr); // 错误:分配与释放方式不匹配
正确方式:
int* ptr = new int(10);
delete ptr;
5.4 placement new:在指定内存中构造对象
C++ 还支持 placement new,可以在已经取得的存储空间中构造对象。
#include <new>
#include <cstdlib>
struct User {
int id;
User(int value) : id(value) {}
};
int main() {
void* memory = std::malloc(sizeof(User));
if (memory == nullptr) {
return 1;
}
User* user = new (memory) User(100);
user->~User();
std::free(memory);
return 0;
}
这里:
malloc只申请原始存储空间。- placement new 在该空间中构造
User对象。 - 显式调用析构函数结束对象生命周期。
free释放原始存储空间。
这说明 C++ 中对象生命周期与存储空间生命周期是两个需要分别理解的概念。
实际使用时还必须满足对齐要求,并确保对象生命周期管理正确。
6. 现代 C++:智能指针与自动资源管理
手动使用 new 和 delete 容易出现内存泄漏、重复释放和异常安全问题。
现代 C++ 推荐使用 RAII(Resource Acquisition Is Initialization)和智能指针管理动态资源。
6.1 RAII 机制
RAII 是一种资源管理思想:
- 在对象构造时获取资源。
- 在对象析构时释放资源。
- 利用对象生命周期管理资源生命周期。
资源不仅包括内存,还可以包括文件句柄、锁、网络连接等。
#include <fstream>
void writeFile() {
std::ofstream file("data.txt");
file << "Hello";
}
当 file 对象离开作用域时,其析构函数会负责关闭文件。
6.2 unique_ptr:独占所有权
std::unique_ptr 表示独占管理某个动态对象。
#include <memory>
int main() {
auto ptr = std::make_unique<int>(100);
return 0;
}
当 ptr 生命周期结束时,其管理的对象会自动释放。
独占所有权意味着同一资源不能同时由多个普通 unique_ptr 实例共同拥有。
auto a = std::make_unique<int>(100);
// auto b = a; // 错误:不能复制 unique_ptr
auto b = std::move(a);
6.3 shared_ptr:共享所有权
std::shared_ptr 通过引用计数管理共享对象。
#include <memory>
int main() {
auto a = std::make_shared<int>(100);
{
auto b = a;
}
return 0;
}
当最后一个共享所有者释放资源时,对象才会被销毁。
其基本过程:
flowchart TB
A["创建 shared_ptr"] --> B["引用计数初始化为 1"]
B --> C["复制 shared_ptr"]
C --> D["引用计数增加"]
D --> E["某个 shared_ptr 离开作用域"]
E --> F["引用计数减少"]
F --> G{"引用计数是否为 0"}
G -->|"否"| H["对象继续存在"]
G -->|"是"| I["销毁对象并释放资源"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
6.4 weak_ptr:弱引用
std::weak_ptr 用于观察由 shared_ptr 管理的对象,但不增加其强引用计数。
常见用途是打破循环引用。
例如,两个对象通过 shared_ptr 相互持有:
struct B;
struct A {
std::shared_ptr<B> b;
};
struct B {
std::shared_ptr<A> a;
};
如果两个对象互相持有,即使外部所有者已经释放,它们的引用计数也可能无法归零,导致资源无法释放。
可以将其中一个方向改为 weak_ptr:
struct B;
struct A {
std::shared_ptr<B> b;
};
struct B {
std::weak_ptr<A> a;
};
通过弱引用观察对象是否仍然存在,可以避免循环引用导致的资源泄漏。
6.5 三种智能指针对比
| 智能指针 | 所有权模型 | 是否增加强引用计数 | 典型用途 |
|---|---|---|---|
unique_ptr |
独占所有权 | 不适用 | 单一对象所有者 |
shared_ptr |
共享所有权 | 是 | 多方共同持有对象 |
weak_ptr |
非拥有式观察 | 否 | 观察共享对象、打破循环引用 |
智能指针可以减少手动管理资源的错误,但不代表完全没有成本。尤其是 shared_ptr,需要维护控制块和引用计数,应该避免在不需要共享所有权时滥用。
7. 垃圾回收机制(Garbage Collection)
C、C++ 通常依赖程序员或资源管理抽象明确管理动态内存。Java、Go、Python 等语言则主要使用自动内存管理机制。
其中,垃圾回收(GC)是一种自动识别并回收不可达对象的机制。
7.1 什么是垃圾对象?
垃圾对象通常指已经无法从程序的有效引用入口访问到的对象。
例如:
User user = new User();
user = null;
如果不存在其他有效引用指向该对象,它就可能成为垃圾回收候选对象。
注意:对象变得不可达,不代表它会立即被回收。回收时间由运行时决定。
7.2 可达性分析
许多现代垃圾回收器采用可达性分析。
其核心思想是从一组根对象(GC Roots)出发,沿着引用关系遍历对象图。
常见根对象包括:
- 当前线程栈中的有效引用。
- 静态变量引用。
- 活跃线程相关引用。
- 虚拟机内部持有的某些引用。
无法从根对象到达的对象,通常可以被判定为不可达。
flowchart TB
A["GC Roots"] --> B["对象 A"]
A --> C["对象 B"]
B --> D["对象 C"]
C --> E["对象 D"]
D --> F["对象 E"]
G["对象 F"] --> H["对象 G"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px