返回专栏
· 19 分钟阅读

内存分配与释放(Memory Allocation & Deallocation)


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 内存分配器

内存分配器负责管理可用内存块,并为程序提供分配与释放接口。

常见职责包括:

  1. 管理空闲内存块。
  2. 根据申请大小选择合适的内存块。
  3. 维护内存块的元数据。
  4. 处理内存对齐要求。
  5. 合并相邻空闲块。
  6. 在需要时向操作系统申请或归还内存。

典型分配过程:

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;
}

这个示例体现了动态内存管理的基本原则:

  1. 申请内存后检查结果。
  2. 使用内存前确保分配成功。
  3. 调整内存大小时使用临时指针。
  4. 释放内存后不再访问原地址。

5. C++ 中的内存分配与释放

C++ 在 C 的基础上提供了 new 和 delete,并进一步引入对象构造、析构、分配函数和智能指针等机制。

5.1 new:分配内存并构造对象

int* ptr = new int(100);

new 表达式通常包含两个阶段:

  1. 获取足够的存储空间。
  2. 在存储空间中构造对象。

对于类对象,构造函数会被调用。

#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 表达式通常包含:

  1. 调用对象的析构函数。
  2. 调用对应的释放函数归还存储空间。
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