C/C++ 内存管理与动态分配核心解析

二、C 语言的动态内存管理

C 语言提供了四个标准库函数来处理堆内存：malloc、calloc、realloc 和 free。

1. realloc 的工作机制

在使用 realloc 扩容或缩容时，有一个常见的陷阱需要注意。

void Test() {
    int* p2 = (int*)calloc(4, sizeof(int));
    int* p3 = (int*)realloc(p2, sizeof(int) * 10);
    free(p3); // 只需释放返回的新指针
}

这里需要 free(p2) 吗？ 不需要，甚至绝对不能这样做。

原因在于 realloc 的内部逻辑：如果内存足够且无需搬迁，它可能直接返回原地址；如果需要搬迁，它会分配新空间，复制数据，然后释放旧空间，最后返回新地址。无论哪种情况，原指针 p2 要么失效，要么已被内部释放。如果你手动执行 free(p2)，会导致'重复释放'（Double Free），这通常会引发程序崩溃。

2. malloc / calloc / realloc 的区别

三、C++ 的动态内存管理

C++ 继承了 C 的内存管理方式，同时引入了更高级的操作符 new 和 delete。

1. 操作内置类型

对于 int、double 等内置类型，new 和 delete 的使用相对直观。

单个变量的分配和释放

int main() {
    // 1. 分配一个未初始化的 int
    int* p1 = new int;
    
    // 2. 分配并初始化为 100
    int* p2 = new int(100);
    
    // 使用完毕后必须释放内存
    delete p1;
    delete p2;
    
    // 良好的习惯：将指针置为空，防止野指针
    p1 = nullptr;
    p2 = nullptr;
    return 0;
}

一维数组的分配与释放

处理数组时，必须使用方括号 [] 来匹配构造和析构过程。

void manageArray() {
    int size = 5;
    // 分配一个长度为 5 的 int 数组
    int* arr = new int[size];
    
    // 初始化数组
    for (int i = 0; i < size; ++i) {
        arr[i] = i * 10;
    }
    
    // 释放数组内存，注意必须加 []
    delete[] arr;
}

2. 操作自定义类型

这是 C++ 内存管理的核心差异点。对于 struct 或 class，new 和 delete 不仅分配内存，还负责调用构造函数和析构函数。

#include <iostream>
using namespace std;

class A {
public:
    A(int a = 0) : _a(a) { cout << "A():" << this << endl; }
    ~A() { cout << "~A():" << this << endl; }
private:
    int _a;
};

int main() {
    // 仅调用 operator new，不调用构造函数
    A* p1 = (A*)operator new(sizeof(A));
    // 调用 operator new + 构造函数
    A* p2 = new A(1);
    
    // 仅调用 operator delete，不调用析构函数
    operator delete(p1);
    // 调用析构函数 + operator delete
    delete p2;
    
    return 0;
}

3. operator new 与 operator delete 函数

• new 和 delete 是用户使用的操作符。
• operator new 和 operator delete 是系统提供的全局函数。

new 表达式 (new expression)：这是一个'全自动'过程，包含两步：

1. 调用 operator new 分配原始内存。
2. 调用构造函数初始化对象。

operator new (函数)：类似于 malloc，唯一任务是分配指定大小的原始内存，不负责构造对象。

operator new 详解

• 原型： void* operator new(size_t size);
• 失败处理： 默认情况下，如果分配失败，它不会返回 nullptr，而是抛出 std::bad_alloc 异常。
• 自定义行为： 你可以重载该函数来实现自己的内存池或审计逻辑。

operator delete 详解

• 原型： void operator delete(void* ptr) noexcept;
• 安全性： 向 operator delete 传递 nullptr 是安全的，函数会直接返回。
• 底层实现： 通常封装了 free() 或者系统底层的内存回收接口。

注：noexcept 说明该函数保证不会抛出异常。

4. new 和 delete 的实现原理

内置类型

new/delete 与 malloc/free 基本类似。区别在于：

• new/delete 申请的是单个元素空间，new[]/delete[] 申请连续空间。
• new 失败抛异常，malloc 返回 NULL。

自定义类型

• new 的原理：
  1. 调用 operator new 函数申请空间。
  2. 在申请的空间上执行构造函数，完成对象的构造。
• delete 的原理：
  1. 在空间上执行析构函数，完成对象中资源的清理工作。
  2. 调用 operator delete 函数释放对象的空间。

5. malloc/free 和 new/delete 的区别

虽然两者都从堆上申请空间，但存在本质差异：

1. 性质不同：malloc/free 是函数，new/delete 是操作符。
2. 初始化：malloc 不初始化，new 可以初始化（内置类型）或调用构造函数（自定义类型）。
3. 语法便捷性：malloc 需手动计算大小，new 后跟类型即可。
4. 返回值：malloc 返回 void* 需强转，new 返回具体类型指针。
5. 错误处理：malloc 失败返回 NULL，需判空；new 失败抛异常，需捕获。
6. 对象生命周期：malloc/free 只管理内存，不管理对象构造/析构；new/delete 全权负责。

掌握这些底层机制，能帮助你在编写高性能 C/C++ 代码时做出更合适的选择，有效规避内存风险。