c++内存管理

1. C/C++内存分布

cpp 复制代码

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____
staticGlobalVar在哪里？____
staticVar在哪里？____
localVar在哪里？____
num1 在哪里？____
char2在哪里？____
*char2在哪里？___
pChar3在哪里？_____
*pChar3在哪里？____
ptr1在哪里？____
*ptr1在哪里？____

✅ 参考答案：

globalVar → C.数据段(静态区)（全局变量）

staticGlobalVar → C.数据段(静态区)（静态全局变量）

staticVar → C.数据段(静态区)（静态局部变量，虽在函数内但存储于静态区）

localVar → A.栈（普通局部变量）

num1 → A.栈（局部数组，数组名代表首元素地址，本身在栈上）

char2 → A.栈（局部字符数组）

*char2 → A.栈 （char2 是数组，内容 "abcd" 存储在栈上开辟的数组中）

pChar3 → A.栈（局部指针变量本身）

*pChar3 → D.代码段(常量区) （指向字符串常量 "abcd"）

ptr1 → A.栈（局部指针变量本身）

*ptr1 → B.堆 （指向 malloc 在堆上申请的空间）> 💡 解题思路 ：先判断变量是全局/静态 还是局部，再判断是指针本身 还是指针指向的内容 。例如 ptr1 是局部指针变量，在栈上；而 *ptr1 指向 malloc 在堆上申请的空间。
🔍 易错点提醒 ：char2[] = "abcd" 与 const char* pChar3 = "abcd" 有本质区别！char2 是数组，"abcd" 被拷贝到栈上；而 pChar3 是指针，指向代码段中的字符串常量 。所以 *char2 在栈上，*pChar3 在代码段。

【说明】

栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
堆用于程序运行时动态内存分配，堆是向上增长的。
数据段--存储全局数据和静态数据。
代码段--可执行的代码/只读常量。

📊 内存分布总结表：

内存区域	存储内容	增长方向
栈	局部变量、函数参数、返回值	向下
堆	动态分配的内存（malloc/new）	向上
数据段	全局变量、静态变量	-
代码段	可执行代码、字符串常量	-

🔑 记忆口诀 ：栈向下、堆向上；局部变量 在栈，全局静态 在数据段；字符串常量在代码段。

2. C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过 new 和 delete 操作符进行动态内存管理。

⚠️ 为什么需要 new/delete？ 因为 malloc/free 是函数，不会调用构造函数 和析构函数，无法满足 C++ 面向对象的需求。
📌 核心对比 ：malloc/free 只负责开辟/释放空间 ；而 new/delete 在开辟/释放空间的基础上，还会调用构造函数/析构函数完成对象的初始化和清理。。
⚠️ 为什么需要 new/delete？ 因为 malloc/free 是函数，不会调用构造函数 和析构函数，无法满足 C++ 面向对象的需求。

2.1 new/delete操作内置类型

cpp 复制代码

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

📌 要点 ：new int(10) 是初始化 为 10；new int[3] 是申请3个 int 的空间。new[] 必须配 delete[]，否则会内存泄漏！
💡 补充说明 ：new int(10) 中的 (10) 是初始化值 ；new int[3] 中的 [3] 是元素个数。两者含义完全不同，注意区分！`
📌 要点 ：new int(10) 是初始化 为 10；new int[3] 是申请3个 int 的空间。new[] 必须配 delete[]，否则会内存泄漏！

2.2 new和delete操作自定义类型

cpp 复制代码

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

int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	A* p7 = new A[3]{ 1,2,3 };//最好
	A* p8 = new A[3]{ A(1),A(2),A(3)};

	delete[] p7;
	p7 = nullptr;
	delete[] p8;
	p8 = nullptr;

	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

3. operator new与operator delete函数

operator new与operator dnew和delete是用户进行动态内存申请和释放的操作符 ，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

🔑 核心关系 ：new → operator new → malloc；delete → operator delete → free。new/delete 是操作符，operator new/operator delete 是函数 ，二者是调用与被调用的关系。
📌 为什么需要 operator new？ 因为 new 作为操作符，需要统一封装 底层的内存申请逻辑（如失败处理、异常抛出），而 operator new 就是这个底层实现函数 ，它内部实际调用 malloc 完成真正的空间申请。数来operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
⚠️ 失败处理对比 ：malloc 申请失败返回 NULL ；而 operator new 申请失败会抛异常 （bad_alloc），这是 C++ 与 C 的重要区别！
💡 代码验证 ：我们可以通过重载全局 operator new 来观察 new 的底层调用过程：

cpp 复制代码

#include <iostream>
#include <cstdlib>
using namespace std;

// 重载全局 operator new，观察 new 的底层调用
void* operator new(size_t size)
{
    cout << "operator new called, size = " << size << endl;
    void* ptr = malloc(size);
    if (ptr == nullptr)
    {
        throw bad_alloc();  // 申请失败抛异常
    }
    return ptr;
}

// 重载全局 operator delete，观察 delete 的底层调用
void operator delete(void* ptr) noexcept
{
    cout << "operator delete called" << endl;
    free(ptr);
}

int main()
{
    int* p = new int(10);   // 触发 operator new
    cout << "*p = " << *p << endl;
    delete p;               // 触发 operator delete
    return 0;
}

🔍 运行结果：
复制代码
operator new called, size = 4
*p = 10
operator delete called
可以看到，new int(10) 底层先调用 operator new 申请空间 ，delete p 底层调用 operator delete 释放空间 。这就是 new/delete 操作符与 operator new/operator delete 函数的真实调用链！来释放空间的。

4. new和delete的实现原理

如果申请的是内置类型 的空间，new 和 malloc，delete 和 free 基本类似，不同的地方是：

单个 vs 连续 ：new/delete 申请和释放的是单个元素 的空间，new[]/delete[] 申请的是连续空间。
失败处理 ：new 在申请空间失败时会抛异常 （bad_alloc），而 malloc 会返回 NULL。

🔑 核心要点 ：对于内置类型 ，new/delete 与 malloc/free 的本质区别仅在于失败处理方式 ------一个抛异常 ，一个返回 NULL。

cpp 复制代码

#include <iostream>
#include <new>   // bad_alloc
using namespace std;

int main()
{
    // 内置类型：new 与 malloc 行为基本一致
    int* p1 = new int(10);        // 申请并初始化为 10
    int* p2 = (int*)malloc(sizeof(int));  // 申请但不初始化

    cout << "*p1 = " << *p1 << endl;  // 输出 10
    // *p2 的值是未定义的（随机值）

    delete p1;      // 释放单个元素
    free(p2);       // 释放单个元素

    // 连续空间：new[] 必须配 delete[]
    int* arr = new int[5]{ 1, 2, 3, 4, 5 };
    delete[] arr;   // 释放连续空间

    // 失败处理对比：new 抛异常，malloc 返回 NULL
    try
    {
        // 申请超大空间，触发失败
        int* huge = new int[1000000000];
        delete[] huge;
    }
    catch (const bad_alloc& e)
    {
        cout << "new 失败，抛出异常: " << e.what() << endl;
    }

    int* p3 = (int*)malloc(1000000000 * sizeof(int));
    if (p3 == nullptr)
    {
        cout << "malloc 失败，返回 NULL" << endl;
    }
    free(p3);

    return 0;
}

💡 运行结果：
复制代码
*p1 = 10
new 失败，抛出异常: std::bad_alloc
malloc 失败，返回 NULL
可以看到，内置类型 下 new/delete 与 malloc/free 的核心差异 在于：new 失败抛异常 ，malloc 失败返回 NULL 。loc会返回NULL。

#对于自定义类型 ，new/delete 与 malloc/free 的本质区别 在于：new/delete 会调用构造函数/析构函数 ，而 malloc/free 不会。

🔴 new 的原理

调用 operator new 函数申请空间
在申请的空间上执行构造函数，完成对象的构造

🔵 delete 的原理

在空间上执行析构函数，完成对象中资源的清理工作
调用 operator delete 函数释放对象的空间

🟢 new T $N$ 的原理

调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成 N 个对象空间的申请
在申请的空间上执行 N 次构造函数

🟡 delete\[\] 的原理

在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理
调用 operator delete[] 释放空间，实际在 operator delete[] 中调用 operator delete 来释放空间

🔑 核心关系 ：new → operator new → malloc；delete → operator delete → free。new/delete 是操作符，operator new/operator delete 是函数 ，二者是调用与被调用的关系。

cpp 复制代码

#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()
{
    cout << "===== new 单个对象 =====" << endl;
    A* p1 = new A(1);   // 1. operator new 申请空间  2. 调用构造函数
    delete p1;          // 1. 调用析构函数  2. operator delete 释放空间

    cout << "\n===== new[] 数组对象 =====" << endl;
    A* p2 = new A[3]{ 1, 2, 3 };  // 1. operator new[] 申请空间  2. 执行 3 次构造函数
    delete[] p2;                  // 1. 执行 3 次析构函数  2. operator delete[] 释放空间

    cout << "\n===== malloc/free 对比 =====" << endl;
    A* p3 = (A*)malloc(sizeof(A));  // 只申请空间，不调用构造函数
    free(p3);                       // 只释放空间，不调用析构函数
    cout << "malloc/free 不会调用构造/析构函数" << endl;

    return 0;
}

🔍 运行结果：
复制代码
===== new 单个对象 =====
A():0x...
~A():0x...

===== new[] 数组对象 =====
A():0x...
A():0x...
A():0x...
~A():0x...
~A():0x...
~A():0x...

===== malloc/free 对比 =====
malloc/free 不会调用构造/析构函数
可以看到，new 会先申请空间再调用构造函数 ，delete 会先调用析构函数再释放空间 ；而 malloc/free 全程不调用构造/析构函数。elete来释放空间

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

malloc/free和nemalloc/free和new/delete的共同点 是：都是从堆上申请空间，并且需要用户手动释放。不同点如下：

本质不同 ：malloc/free 是函数，new/delete 是操作符
初始化 ：malloc 申请的空间不会初始化 ，new 可以初始化
空间大小 ：malloc 需手动计算 空间大小并传递，new 只需跟上类型 即可，多个对象用 [] 指定个数
返回值 ：malloc 返回 void*，使用时必须强转 ；new 不需要，因为类型已确定
失败处理 ：malloc 失败返回 NULL ，必须判空；new 失败抛异常 ，需捕获异常
自定义类型 ：malloc/free 只开空间 ，不调用构造/析构函数；new/delete 会调用构造/析构函数完成初始化和清理

🔑 一句话总结 ：malloc/free 是 C 语言 的函数，只管开空间/释放 ；new/delete 是 C++ 的操作符 ，在开空间/释放的基础上，还会调用构造/析构函数 ，并支持初始化 与异常处理。
💡 记忆口诀 ：函数 vs 操作符 、不初始化 vs 可初始化 、手动算大小 vs 自动跟类型 、强转 vs 免强转 、判空 vs 捕获异常 、不调构造 vs 调构造。的清理释放。

1. C/C++内存分布

2. C++内存管理方式

2.1 new/delete操作内置类型

2.2 new和delete操作自定义类型

3. operator new与operator delete函数

4. new和delete的实现原理

🔴 new 的原理

🔵 delete 的原理

🟢 new TN 的原理

🟡 delete\[\] 的原理

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

🟢 new T $N$ 的原理