引言

在C++开发和面试中， new / delete 与 malloc / free 的区别是绕不开的核心考点。它们看似都是“内存分配与释放工具”，但本质是C++面向对象的“对象生命周期管理器” 与C语言的“原始内存操作工具” 的差异。本文将从基础区别、底层实现、实战场景三个维度全面拆解，既保证深度，又兼顾通俗易懂，适合收藏作为学习笔记~

一、基础区别

1.核心身份与设计目标

工具	身份类型	设计目标	核心特性
new	C++ 运算符	创建C++对象（分配内存+初始化）	自动调用构造函数、类型安全
malloc	C标准库函数	分配原始字节内存	仅分配内存、无初始化、返回
delete	C++ 运算符	销毁C++对象（释放资源+回收内存）	自动调用析构函数、匹配
free	C标准库函数	回收原始字节内存	仅释放内存、无析构、匹配

2.语法与使用场景对比

（1）new vs malloc：

#include <iostream>
#include <cstdlib> // malloc所需头文件
using namespace std;

class Student {
public:
    Student(string name, int age) : m_name(name), m_age(age) {
        cout << "构造函数执行：" << m_name << " 初始化" << endl;
    }
    ~Student() {
        cout << "析构函数执行：" << m_name << " 资源释放" << endl;
    }
private:
    string m_name;
    int m_age;
};

int main() {
    // 1. new 的使用：直接创建对象（一步完成分配+构造）
    Student* stu1 = new Student("小明", 18); // 无需强转、自动调用构造
    int* arr1 = new int[5]{1,2,3,4,5};     // 支持数组初始化（C++11+）

    // 2. malloc 的使用：仅分配原始内存（需手动强转+初始化）
    Student* stu2 = (Student*)malloc(sizeof(Student)); // 必须强转
    int* arr2 = (int*)malloc(5 * sizeof(int));         // 内存是垃圾值，需手动赋值
    if (arr2 != nullptr) {
        for (int i=0; i<5; i++) arr2[i] = i+1; // 手动初始化
    }

    // 释放（后续详解）
    delete stu1;
    delete[] arr1;
    free(stu2); // 不会调用析构函数
    free(arr2);
    return 0;
}

（2）关键语法差异总结

• new ：无需计算字节数（编译器自动通过 sizeof(T) 获取）、无需强转、支持构造参数传递；
• malloc ：必须显式传入字节数（ sizeof(T) * 数量 ）、返回 void* 需强转、无初始化逻辑；
• 数组支持： new[] 可直接创建数组（ new T[n] ）， malloc 需手动计算数组总字节数。

3.其他基础差异

对比维度	new / delete	malloc / free
类型安全	是（返回T*，与目标类型匹配）	否（返回void* ，强转易出错）
异常处理	分配失败抛std::bad_alloc异常（默认）	分配失败返回nullptr，需手动检查
重载支持	可重载operator new / operator delete	不可重载，仅能全局替换底层分配器
资源管理	自动调用构造/析构（管理对象资源）	不处理资源，仅操作内存字节
适用场景	C++对象、面向对象开发（符合RAII思想）	C语言兼容、原始内存控制、底层开发

二、底层实现深度拆解

1.new的底层实现：两步走（分配内存+构造对象）

new T(参数) 看似是“一步调用”，但编译器会自动拆解为两个核心步骤，且这两步不可颠倒：

步骤1：调用 operator new 分配原始内存

new 运算符的核心依赖是 operator new 函数（全局或类自定义），其作用是“获取足够大的原始内存”。

（1）默认全局 operator new 实现（主流编译器如GCC、MSVC）：
本质是对 malloc 的“包装增强”，增加了C++标准要求的异常处理和重试机制，伪代码如下：

// 标准库默认全局 operator new 伪代码
void* operator new(size_t size) throw(std::bad_alloc) {
    while (true) {
        // 核心：调用 malloc 分配原始内存
        void* raw_mem = malloc(size);
        if (raw_mem != nullptr) {
            return raw_mem; // 分配成功，返回原始内存地址
        }
        // 分配失败：调用 new_handler 尝试释放内存（标准重试机制）
        std::new_handler handler = std::set_new_handler(nullptr);
        std::set_new_handler(handler);
        if (handler) {
            handler(); // 执行用户注册的内存释放回调（如释放无用资源）
        } else {
            throw std::bad_alloc(); // 无回调则抛异常
        }
    }
}

（2）关键说明：

• 内存大小： size 由编译器自动计算（ sizeof(T) + 内存对齐开销）；
• 自定义扩展：开发者可重载 operator new （全局或类级别），替换为内存池、静态内存等分配逻辑（此时与 malloc 无关）。

步骤2：调用构造函数初始化对象

拿到 operator new 返回的原始内存后，编译器会自动插入代码，在该内存上调用 T 的构造函数，将“原始内存”转化为“有效对象”。

（1）底层伪代码还原（编译器视角）：

// new Student("小明", 18) 的底层等价逻辑
Student* create_student() {
    // 步骤1：分配原始内存
    void* raw_mem = operator new(sizeof(Student));
    // 步骤2：在原始内存上构造对象
    Student* obj = static_cast<Student*>(raw_mem);
    obj->Student("小明", 18); // 编译器自动调用构造函数（开发者无法手动写这行）
    return obj;
}

（2）核心：构造函数的参数由 new 后的括号直接传递，内存地址不变（对象就“诞生”在这块内存上）。

2. malloc 的底层实现：仅分配原始内存

malloc 是C标准库的底层内存分配函数，其核心逻辑是“从堆中申请一块连续的字节内存”，无任何C++面向对象特性：

（1）底层原理：

• 依赖操作系统的堆管理接口（如Linux的 brk / mmap ，Windows的 HeapAlloc ）；
• 内部维护“空闲内存链表”，分配时查找匹配大小的空闲块（最优适配/首次适配等算法），并处理内存对齐；
• 不关心内存的用途：分配后内存中是随机垃圾值，需用户手动初始化（如 memset 或赋值）。

（2）关键限制：

• 无法直接创建C++对象：因为不会调用构造函数，即使强转为 T* ，对象成员也未初始化（如 string 类型会是无效状态）；
• 无异常机制：分配失败仅返回 nullptr ，需用户手动检查。

3. delete 的底层实现：两步走（析构对象 + 释放内存）

delete obj 是 new obj 的逆操作，同样拆解为两步，顺序不可颠倒：

步骤1：调用析构函数释放资源

编译器先调用 obj 指向对象的析构函数，释放对象持有的资源（如动态内存、文件句柄、网络连接等）。

• 关键：析构函数仅释放“对象资源”，不回收内存本身。

步骤2：调用 operator delete 回收内存

析构完成后，调用 operator delete 函数，将内存归还给分配器（如堆、内存池）。

• 默认全局 operator delete 实现：
  本质是对 free 的简单包装，伪代码如下：

void operator delete(void* ptr) throw() {
    if (ptr != nullptr) {
        free(ptr); // 直接调用 free 释放内存
    }
}

• 数组特殊处理： delete[]

• 若用 new[] 创建数组（如 new Student[5] ），必须用 delete[] 释放；

• 底层逻辑： delete[] 会先调用数组中每个元素的析构函数（从后往前），再调用 operator delete[] 释放整块内存；

• 错误后果：用 delete 释放 new[] 创建的数组，会导致仅第一个元素被析构，其余元素资源泄漏，且内存释放可能异常（未定义行为）。

4. free 的底层实现：仅释放内存

free 是 malloc 的配套释放函数，核心逻辑是“将内存归还给堆”，无任何析构行为：

• 底层原理：

  • 不检查内存内容：仅根据 ptr 指向的内存块头部信息（ malloc 分配时记录的大小、对齐等），将内存块归还给空闲链表；
  • 不修改指针值： free(ptr) 后， ptr 仍指向原内存地址（变为“野指针”），需手动置为 nullptr 。

• 关键禁忌：

  • 不能释放 new 创建的对象： free 不会调用析构函数，导致对象资源泄漏；
  • 不能重复释放、释放空指针（虽安全但无意义）、释放非 malloc 分配的内存（如栈内存）。

三、常见错误

错误用法	后果
new分配的内存用free释放	析构函数未调用 → 资源泄漏（如string的动态内存未释放）
malloc分配的内存用delete释放	析构函数被调用，但对象未构造 → 未定义行为（程序崩溃）
new[]创建数组用delete释放	仅第一个元素析构 → 资源泄漏+内存释放异常
忽略malloc分配后的初始化	内存中是垃圾值 → 逻辑错误（如野指针、随机值）
重复释放或释放空指针（无意义）	程序崩溃（重复释放）或无影响（空指针）

四、总结

1. 本质区别： new / delete 管“对象生命周期”（构造+析构+内存）， malloc / free 管“原始内存”（仅分配+释放）；

2. 底层关联：默认全局 operator new / operator delete 依赖 malloc / free ，但可通过重载替换；

3. 使用原则：C++开发优先用 new / delete （符合RAII），仅C兼容/特殊场景用 malloc / free ，严禁混用；

4. 面试关键： new 的两步流程（分配→构造）、 delete[] 的数组处理、 operator new 的重载能力。